Lines Matching refs:self
48 _bufferediobase_readinto_generic(PyObject *self, Py_buffer *buffer, char readinto1)
56 data = _PyObject_CallMethod(self, attr, "n", buffer->len);
89 _io__BufferedIOBase_readinto_impl(PyObject *self, Py_buffer *buffer)
92 return _bufferediobase_readinto_generic(self, buffer, 0);
102 _io__BufferedIOBase_readinto1_impl(PyObject *self, Py_buffer *buffer)
105 return _bufferediobase_readinto_generic(self, buffer, 1);
127 _io__BufferedIOBase_detach_impl(PyObject *self)
152 bufferediobase_read(PyObject *self, PyObject *args)
165 bufferediobase_read1(PyObject *self, PyObject *args)
180 bufferediobase_write(PyObject *self, PyObject *args)
256 _enter_buffered_busy(buffered *self)
260 if (self->owner == PyThread_get_thread_ident()) {
262 "reentrant call inside %R", self);
268 st = PyThread_acquire_lock(self->lock, 1);
276 st = PyThread_acquire_lock_timed(self->lock, (PY_TIMEOUT_T)1e6, 0);
280 PyObject *ascii = PyObject_ASCII((PyObject*)self);
284 ascii ? PyUnicode_AsUTF8(ascii) : "<ascii(self) failed>");
289 #define ENTER_BUFFERED(self) \
290 ( (PyThread_acquire_lock(self->lock, 0) ? \
291 1 : _enter_buffered_busy(self)) \
292 && (self->owner = PyThread_get_thread_ident(), 1) )
294 #define LEAVE_BUFFERED(self) \
296 self->owner = 0; \
297 PyThread_release_lock(self->lock); \
300 #define CHECK_INITIALIZED(self) \
301 if (self->ok <= 0) { \
302 if (self->detached) { \
312 #define CHECK_INITIALIZED_INT(self) \
313 if (self->ok <= 0) { \
314 if (self->detached) { \
324 #define IS_CLOSED(self) \
325 (!self->buffer || \
326 (self->fast_closed_checks \
327 ? _PyFileIO_closed(self->raw) \
328 : buffered_closed(self)))
330 #define CHECK_CLOSED(self, error_msg) \
331 if (IS_CLOSED(self) && (Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t) == 0)) { \
336 #define VALID_READ_BUFFER(self) \
337 (self->readable && self->read_end != -1)
339 #define VALID_WRITE_BUFFER(self) \
340 (self->writable && self->write_end != -1)
342 #define ADJUST_POSITION(self, _new_pos) \
344 self->pos = _new_pos; \
345 if (VALID_READ_BUFFER(self) && self->read_end < self->pos) \
346 self->read_end = self->pos; \
349 #define READAHEAD(self) \
350 ((self->readable && VALID_READ_BUFFER(self)) \
351 ? (self->read_end - self->pos) : 0)
353 #define RAW_OFFSET(self) \
354 (((VALID_READ_BUFFER(self) || VALID_WRITE_BUFFER(self)) \
355 && self->raw_pos >= 0) ? self->raw_pos - self->pos : 0)
357 #define RAW_TELL(self) \
358 (self->abs_pos != -1 ? self->abs_pos : _buffered_raw_tell(self))
360 #define MINUS_LAST_BLOCK(self, size) \
361 (self->buffer_mask ? \
362 (size & ~self->buffer_mask) : \
363 (self->buffer_size * (size / self->buffer_size)))
367 buffered_dealloc(buffered *self)
369 self->finalizing = 1;
370 if (_PyIOBase_finalize((PyObject *) self) < 0)
372 _PyObject_GC_UNTRACK(self);
373 self->ok = 0;
374 if (self->weakreflist != NULL)
375 PyObject_ClearWeakRefs((PyObject *)self);
376 Py_CLEAR(self->raw);
377 if (self->buffer) {
378 PyMem_Free(self->buffer);
379 self->buffer = NULL;
381 if (self->lock) {
382 PyThread_free_lock(self->lock);
383 self->lock = NULL;
385 Py_CLEAR(self->dict);
386 Py_TYPE(self)->tp_free((PyObject *)self);
390 buffered_sizeof(buffered *self, PyObject *Py_UNUSED(ignored))
394 res = _PyObject_SIZE(Py_TYPE(self));
395 if (self->buffer)
396 res += self->buffer_size;
401 buffered_traverse(buffered *self, visitproc visit, void *arg)
403 Py_VISIT(self->raw);
404 Py_VISIT(self->dict);
409 buffered_clear(buffered *self)
411 self->ok = 0;
412 Py_CLEAR(self->raw);
413 Py_CLEAR(self->dict);
421 buffered_dealloc_warn(buffered *self, PyObject *source)
423 if (self->ok && self->raw) {
425 r = PyObject_CallMethodOneArg(self->raw, &_Py_ID(_dealloc_warn), source);
443 buffered_simple_flush(buffered *self, PyObject *args)
445 CHECK_INITIALIZED(self)
446 return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(flush));
450 buffered_closed(buffered *self)
454 CHECK_INITIALIZED_INT(self)
455 res = PyObject_GetAttr(self->raw, &_Py_ID(closed));
464 buffered_closed_get(buffered *self, void *context)
466 CHECK_INITIALIZED(self)
467 return PyObject_GetAttr(self->raw, &_Py_ID(closed));
471 buffered_close(buffered *self, PyObject *args)
476 CHECK_INITIALIZED(self)
477 if (!ENTER_BUFFERED(self))
480 r = buffered_closed(self);
489 if (self->finalizing) {
490 PyObject *r = buffered_dealloc_warn(self, (PyObject *) self);
497 LEAVE_BUFFERED(self)
498 res = PyObject_CallMethodNoArgs((PyObject *)self, &_Py_ID(flush));
499 if (!ENTER_BUFFERED(self))
506 res = PyObject_CallMethodNoArgs(self->raw, &_Py_ID(close));
508 if (self->buffer) {
509 PyMem_Free(self->buffer);
510 self->buffer = NULL;
518 self->read_end = 0;
519 self->pos = 0;
522 LEAVE_BUFFERED(self)
529 buffered_detach(buffered *self, PyObject *Py_UNUSED(ignored))
532 CHECK_INITIALIZED(self)
533 res = PyObject_CallMethodNoArgs((PyObject *)self, &_Py_ID(flush));
537 raw = self->raw;
538 self->raw = NULL;
539 self->detached = 1;
540 self->ok = 0;
547 buffered_seekable(buffered *self, PyObject *Py_UNUSED(ignored))
549 CHECK_INITIALIZED(self)
550 return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(seekable));
554 buffered_readable(buffered *self, PyObject *Py_UNUSED(ignored))
556 CHECK_INITIALIZED(self)
557 return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(readable));
561 buffered_writable(buffered *self, PyObject *Py_UNUSED(ignored))
563 CHECK_INITIALIZED(self)
564 return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(writable));
568 buffered_name_get(buffered *self, void *context)
570 CHECK_INITIALIZED(self)
571 return PyObject_GetAttr(self->raw, &_Py_ID(name));
575 buffered_mode_get(buffered *self, void *context)
577 CHECK_INITIALIZED(self)
578 return PyObject_GetAttr(self->raw, &_Py_ID(mode));
584 buffered_fileno(buffered *self, PyObject *Py_UNUSED(ignored))
586 CHECK_INITIALIZED(self)
587 return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(fileno));
591 buffered_isatty(buffered *self, PyObject *Py_UNUSED(ignored))
593 CHECK_INITIALIZED(self)
594 return PyObject_CallMethodNoArgs(self->raw, &_Py_ID(isatty));
601 _bufferedreader_fill_buffer(buffered *self);
603 _bufferedreader_reset_buf(buffered *self);
605 _bufferedwriter_reset_buf(buffered *self);
607 _bufferedreader_peek_unlocked(buffered *self);
609 _bufferedreader_read_all(buffered *self);
611 _bufferedreader_read_fast(buffered *self, Py_ssize_t);
613 _bufferedreader_read_generic(buffered *self, Py_ssize_t);
615 _bufferedreader_raw_read(buffered *self, char *start, Py_ssize_t len);
654 _buffered_raw_tell(buffered *self)
658 res = PyObject_CallMethodNoArgs(self->raw, &_Py_ID(tell));
670 self->abs_pos = n;
675 _buffered_raw_seek(buffered *self, Py_off_t target, int whence)
688 res = PyObject_CallMethodObjArgs(self->raw, &_Py_ID(seek),
703 self->abs_pos = n;
708 _buffered_init(buffered *self)
711 if (self->buffer_size <= 0) {
716 if (self->buffer)
717 PyMem_Free(self->buffer);
718 self->buffer = PyMem_Malloc(self->buffer_size);
719 if (self->buffer == NULL) {
723 if (self->lock)
724 PyThread_free_lock(self->lock);
725 self->lock = PyThread_allocate_lock();
726 if (self->lock == NULL) {
730 self->owner = 0;
733 for (n = self->buffer_size - 1; n & 1; n >>= 1)
736 self->buffer_mask = self->buffer_size - 1;
738 self->buffer_mask = 0;
739 if (_buffered_raw_tell(self) == -1)
782 buffered_flush_and_rewind_unlocked(buffered *self)
786 res = _bufferedwriter_flush_unlocked(self);
791 if (self->readable) {
795 n = _buffered_raw_seek(self, -RAW_OFFSET(self), 1);
796 _bufferedreader_reset_buf(self);
804 buffered_flush(buffered *self, PyObject *args)
808 CHECK_INITIALIZED(self)
809 CHECK_CLOSED(self, "flush of closed file")
811 if (!ENTER_BUFFERED(self))
813 res = buffered_flush_and_rewind_unlocked(self);
814 LEAVE_BUFFERED(self)
827 _io__Buffered_peek_impl(buffered *self, Py_ssize_t size)
832 CHECK_INITIALIZED(self)
833 CHECK_CLOSED(self, "peek of closed file")
835 if (!ENTER_BUFFERED(self))
838 if (self->writable) {
839 res = buffered_flush_and_rewind_unlocked(self);
844 res = _bufferedreader_peek_unlocked(self);
847 LEAVE_BUFFERED(self)
858 _io__Buffered_read_impl(buffered *self, Py_ssize_t n)
863 CHECK_INITIALIZED(self)
870 CHECK_CLOSED(self, "read of closed file")
874 if (!ENTER_BUFFERED(self))
876 res = _bufferedreader_read_all(self);
879 res = _bufferedreader_read_fast(self, n);
883 if (!ENTER_BUFFERED(self))
885 res = _bufferedreader_read_generic(self, n);
888 LEAVE_BUFFERED(self)
899 _io__Buffered_read1_impl(buffered *self, Py_ssize_t n)
905 CHECK_INITIALIZED(self)
907 n = self->buffer_size;
910 CHECK_CLOSED(self, "read of closed file")
918 have = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
921 res = _bufferedreader_read_fast(self, n);
928 if (!ENTER_BUFFERED(self)) {
932 _bufferedreader_reset_buf(self);
933 r = _bufferedreader_raw_read(self, PyBytes_AS_STRING(res), n);
934 LEAVE_BUFFERED(self)
947 _buffered_readinto_generic(buffered *self, Py_buffer *buffer, char readinto1)
952 CHECK_INITIALIZED(self)
953 CHECK_CLOSED(self, "readinto of closed file")
955 n = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
958 memcpy(buffer->buf, self->buffer + self->pos, buffer->len);
959 self->pos += buffer->len;
962 memcpy(buffer->buf, self->buffer + self->pos, n);
963 self->pos += n;
967 if (!ENTER_BUFFERED(self))
970 if (self->writable) {
971 res = buffered_flush_and_rewind_unlocked(self);
977 _bufferedreader_reset_buf(self);
978 self->pos = 0;
985 if (remaining > self->buffer_size) {
986 n = _bufferedreader_raw_read(self, (char *) buffer->buf + written,
993 n = _bufferedreader_fill_buffer(self);
998 self->buffer + self->pos, n);
999 self->pos += n;
1025 LEAVE_BUFFERED(self);
1036 _io__Buffered_readinto_impl(buffered *self, Py_buffer *buffer)
1039 return _buffered_readinto_generic(self, buffer, 0);
1049 _io__Buffered_readinto1_impl(buffered *self, Py_buffer *buffer)
1052 return _buffered_readinto_generic(self, buffer, 1);
1057 _buffered_readline(buffered *self, Py_ssize_t limit)
1064 CHECK_CLOSED(self, "readline of closed file")
1069 n = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
1072 start = self->buffer + self->pos;
1077 self->pos += s - start + 1;
1083 self->pos += n;
1087 if (!ENTER_BUFFERED(self))
1103 self->pos += n;
1107 if (self->writable) {
1108 PyObject *r = buffered_flush_and_rewind_unlocked(self);
1115 _bufferedreader_reset_buf(self);
1116 n = _bufferedreader_fill_buffer(self);
1123 start = self->buffer;
1131 self->pos = s - start;
1139 self->pos = n;
1158 LEAVE_BUFFERED(self)
1171 _io__Buffered_readline_impl(buffered *self, Py_ssize_t size)
1174 CHECK_INITIALIZED(self)
1175 return _buffered_readline(self, size);
1180 buffered_tell(buffered *self, PyObject *Py_UNUSED(ignored))
1184 CHECK_INITIALIZED(self)
1185 pos = _buffered_raw_tell(self);
1188 pos -= RAW_OFFSET(self);
1201 _io__Buffered_seek_impl(buffered *self, PyObject *targetobj, int whence)
1207 CHECK_INITIALIZED(self)
1225 CHECK_CLOSED(self, "seek of closed file")
1227 if (_PyIOBase_check_seekable(self->raw, Py_True) == NULL)
1238 if (((whence == 0) || (whence == 1)) && self->readable) {
1246 current = RAW_TELL(self);
1247 avail = READAHEAD(self);
1251 offset = target - (current - RAW_OFFSET(self));
1254 if (offset >= -self->pos && offset <= avail) {
1255 self->pos += offset;
1261 if (!ENTER_BUFFERED(self))
1265 if (self->writable) {
1266 res = _bufferedwriter_flush_unlocked(self);
1274 target -= RAW_OFFSET(self);
1275 n = _buffered_raw_seek(self, target, whence);
1278 self->raw_pos = -1;
1280 if (res != NULL && self->readable)
1281 _bufferedreader_reset_buf(self);
1284 LEAVE_BUFFERED(self)
1295 _io__Buffered_truncate_impl(buffered *self, PyObject *pos)
1300 CHECK_INITIALIZED(self)
1301 CHECK_CLOSED(self, "truncate of closed file")
1302 if (!self->writable) {
1305 if (!ENTER_BUFFERED(self))
1308 res = buffered_flush_and_rewind_unlocked(self);
1314 res = PyObject_CallMethodOneArg(self->raw, &_Py_ID(truncate), pos);
1318 if (_buffered_raw_tell(self) == -1)
1322 LEAVE_BUFFERED(self)
1327 buffered_iternext(buffered *self)
1332 CHECK_INITIALIZED(self);
1334 tp = Py_TYPE(self);
1338 line = _buffered_readline(self, -1);
1341 line = PyObject_CallMethodNoArgs((PyObject *)self,
1365 buffered_repr(buffered *self)
1369 if (_PyObject_LookupAttr((PyObject *) self, &_Py_ID(name), &nameobj) < 0) {
1377 res = PyUnicode_FromFormat("<%s>", Py_TYPE(self)->tp_name);
1380 int status = Py_ReprEnter((PyObject *)self);
1384 Py_TYPE(self)->tp_name, nameobj);
1385 Py_ReprLeave((PyObject *)self);
1390 Py_TYPE(self)->tp_name);
1401 static void _bufferedreader_reset_buf(buffered *self)
1403 self->read_end = -1;
1415 _io_BufferedReader___init___impl(buffered *self, PyObject *raw,
1419 self->ok = 0;
1420 self->detached = 0;
1426 Py_XSETREF(self->raw, raw);
1427 self->buffer_size = buffer_size;
1428 self->readable = 1;
1429 self->writable = 0;
1431 if (_buffered_init(self) < 0)
1433 _bufferedreader_reset_buf(self);
1435 self->fast_closed_checks = (Py_IS_TYPE(self, &PyBufferedReader_Type) &&
1438 self->ok = 1;
1443 _bufferedreader_raw_read(buffered *self, char *start, Py_ssize_t len)
1460 res = PyObject_CallMethodOneArg(self->raw, &_Py_ID(readinto), memobj);
1487 if (n > 0 && self->abs_pos != -1)
1488 self->abs_pos += n;
1493 _bufferedreader_fill_buffer(buffered *self)
1496 if (VALID_READ_BUFFER(self))
1497 start = Py_SAFE_DOWNCAST(self->read_end, Py_off_t, Py_ssize_t);
1500 len = self->buffer_size - start;
1501 n = _bufferedreader_raw_read(self, self->buffer + start, len);
1504 self->read_end = start + n;
1505 self->raw_pos = start + n;
1510 _bufferedreader_read_all(buffered *self)
1516 current_size = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
1519 self->buffer + self->pos, current_size);
1522 self->pos += current_size;
1525 if (self->writable) {
1526 tmp = buffered_flush_and_rewind_unlocked(self);
1531 _bufferedreader_reset_buf(self);
1533 if (_PyObject_LookupAttr(self->raw, &_Py_ID(readall), &readall) < 0) {
1568 data = PyObject_CallMethodNoArgs(self->raw, &_Py_ID(read));
1587 if (self->abs_pos != -1)
1588 self->abs_pos += PyBytes_GET_SIZE(data);
1602 _bufferedreader_read_fast(buffered *self, Py_ssize_t n)
1606 current_size = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
1609 PyObject *res = PyBytes_FromStringAndSize(self->buffer + self->pos, n);
1611 self->pos += n;
1621 _bufferedreader_read_generic(buffered *self, Py_ssize_t n)
1627 current_size = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
1629 return _bufferedreader_read_fast(self, n);
1638 memcpy(out, self->buffer + self->pos, current_size);
1641 self->pos += current_size;
1644 if (self->writable) {
1645 PyObject *r = buffered_flush_and_rewind_unlocked(self);
1650 _bufferedreader_reset_buf(self);
1654 Py_ssize_t r = MINUS_LAST_BLOCK(self, remaining);
1657 r = _bufferedreader_raw_read(self, out + written, r);
1673 assert(remaining <= self->buffer_size);
1674 self->pos = 0;
1675 self->raw_pos = 0;
1676 self->read_end = 0;
1680 while (remaining > 0 && self->read_end < self->buffer_size) {
1681 Py_ssize_t r = _bufferedreader_fill_buffer(self);
1695 memcpy(out + written, self->buffer + self->pos, r);
1697 self->pos += r;
1701 memcpy(out + written, self->buffer + self->pos, remaining);
1703 self->pos += remaining;
1718 _bufferedreader_peek_unlocked(buffered *self)
1722 have = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
1730 return PyBytes_FromStringAndSize(self->buffer + self->pos, have);
1734 _bufferedreader_reset_buf(self);
1735 r = _bufferedreader_fill_buffer(self);
1740 self->pos = 0;
1741 return PyBytes_FromStringAndSize(self->buffer, r);
1751 _bufferedwriter_reset_buf(buffered *self)
1753 self->write_pos = 0;
1754 self->write_end = -1;
1770 _io_BufferedWriter___init___impl(buffered *self, PyObject *raw,
1774 self->ok = 0;
1775 self->detached = 0;
1781 Py_XSETREF(self->raw, raw);
1782 self->readable = 0;
1783 self->writable = 1;
1785 self->buffer_size = buffer_size;
1786 if (_buffered_init(self) < 0)
1788 _bufferedwriter_reset_buf(self);
1789 self->pos = 0;
1791 self->fast_closed_checks = (Py_IS_TYPE(self, &PyBufferedWriter_Type) &&
1794 self->ok = 1;
1799 _bufferedwriter_raw_write(buffered *self, char *start, Py_ssize_t len)
1818 res = PyObject_CallMethodOneArg(self->raw, &_Py_ID(write), memobj);
1840 if (n > 0 && self->abs_pos != -1)
1841 self->abs_pos += n;
1846 _bufferedwriter_flush_unlocked(buffered *self)
1850 if (!VALID_WRITE_BUFFER(self) || self->write_pos == self->write_end)
1853 rewind = RAW_OFFSET(self) + (self->pos - self->write_pos);
1855 n = _buffered_raw_seek(self, -rewind, 1);
1859 self->raw_pos -= rewind;
1861 while (self->write_pos < self->write_end) {
1862 n = _bufferedwriter_raw_write(self,
1863 self->buffer + self->write_pos,
1864 Py_SAFE_DOWNCAST(self->write_end - self->write_pos,
1874 self->write_pos += n;
1875 self->raw_pos = self->write_pos;
1886 VALID_WRITE_BUFFER(self) returns false.
1889 after flushing and if VALID_READ_BUFFER(self) is false, we need
1890 VALID_WRITE_BUFFER(self) to be false to have
1891 RAW_OFFSET(self) == 0.
1894 _bufferedwriter_reset_buf(self);
1908 _io_BufferedWriter_write_impl(buffered *self, Py_buffer *buffer)
1915 CHECK_INITIALIZED(self)
1917 if (!ENTER_BUFFERED(self))
1922 if (IS_CLOSED(self)) {
1928 if (!VALID_READ_BUFFER(self) && !VALID_WRITE_BUFFER(self)) {
1929 self->pos = 0;
1930 self->raw_pos = 0;
1932 avail = Py_SAFE_DOWNCAST(self->buffer_size - self->pos, Py_off_t, Py_ssize_t);
1934 memcpy(self->buffer + self->pos, buffer->buf, buffer->len);
1935 if (!VALID_WRITE_BUFFER(self) || self->write_pos > self->pos) {
1936 self->write_pos = self->pos;
1938 ADJUST_POSITION(self, self->pos + buffer->len);
1939 if (self->pos > self->write_end)
1940 self->write_end = self->pos;
1946 res = _bufferedwriter_flush_unlocked(self);
1951 if (self->readable)
1952 _bufferedreader_reset_buf(self);
1954 assert(VALID_WRITE_BUFFER(self));
1955 memmove(self->buffer, self->buffer + self->write_pos,
1956 Py_SAFE_DOWNCAST(self->write_end - self->write_pos,
1958 self->write_end -= self->write_pos;
1959 self->raw_pos -= self->write_pos;
1960 self->pos -= self->write_pos;
1961 self->write_pos = 0;
1962 avail = Py_SAFE_DOWNCAST(self->buffer_size - self->write_end,
1967 memcpy(self->buffer + self->write_end, buffer->buf, buffer->len);
1968 self->write_end += buffer->len;
1969 self->pos += buffer->len;
1974 memcpy(self->buffer + self->write_end, buffer->buf, avail);
1975 self->write_end += avail;
1976 self->pos += avail;
1992 offset = RAW_OFFSET(self);
1994 if (_buffered_raw_seek(self, -offset, 1) < 0)
1996 self->raw_pos -= offset;
2002 while (remaining > self->buffer_size) {
2004 self, (char *) buffer->buf + written, buffer->len - written);
2009 if (remaining > self->buffer_size) {
2011 memcpy(self->buffer,
2012 (char *) buffer->buf + written, self->buffer_size);
2013 self->raw_pos = 0;
2014 ADJUST_POSITION(self, self->buffer_size);
2015 self->write_end = self->buffer_size;
2016 written += self->buffer_size;
2032 if (self->readable)
2033 _bufferedreader_reset_buf(self);
2035 memcpy(self->buffer, (char *) buffer->buf + written, remaining);
2038 self->write_pos = 0;
2040 self->write_end = remaining;
2041 ADJUST_POSITION(self, remaining);
2042 self->raw_pos = 0;
2048 LEAVE_BUFFERED(self)
2090 _io_BufferedRWPair___init___impl(rwpair *self, PyObject *reader,
2099 self->reader = (buffered *) PyObject_CallFunction(
2101 if (self->reader == NULL)
2104 self->writer = (buffered *) PyObject_CallFunction(
2106 if (self->writer == NULL) {
2107 Py_CLEAR(self->reader);
2115 bufferedrwpair_traverse(rwpair *self, visitproc visit, void *arg)
2117 Py_VISIT(self->dict);
2122 bufferedrwpair_clear(rwpair *self)
2124 Py_CLEAR(self->reader);
2125 Py_CLEAR(self->writer);
2126 Py_CLEAR(self->dict);
2131 bufferedrwpair_dealloc(rwpair *self)
2133 _PyObject_GC_UNTRACK(self);
2134 if (self->weakreflist != NULL)
2135 PyObject_ClearWeakRefs((PyObject *)self);
2136 Py_CLEAR(self->reader);
2137 Py_CLEAR(self->writer);
2138 Py_CLEAR(self->dict);
2139 Py_TYPE(self)->tp_free((PyObject *) self);
2143 _forward_call(buffered *self, PyObject *name, PyObject *args)
2146 if (self == NULL) {
2152 func = PyObject_GetAttr((PyObject *)self, name);
2164 bufferedrwpair_read(rwpair *self, PyObject *args)
2166 return _forward_call(self->reader, &_Py_ID(read), args);
2170 bufferedrwpair_peek(rwpair *self, PyObject *args)
2172 return _forward_call(self->reader, &_Py_ID(peek), args);
2176 bufferedrwpair_read1(rwpair *self, PyObject *args)
2178 return _forward_call(self->reader, &_Py_ID(read1), args);
2182 bufferedrwpair_readinto(rwpair *self, PyObject *args)
2184 return _forward_call(self->reader, &_Py_ID(readinto), args);
2188 bufferedrwpair_readinto1(rwpair *self, PyObject *args)
2190 return _forward_call(self->reader, &_Py_ID(readinto1), args);
2194 bufferedrwpair_write(rwpair *self, PyObject *args)
2196 return _forward_call(self->writer, &_Py_ID(write), args);
2200 bufferedrwpair_flush(rwpair *self, PyObject *Py_UNUSED(ignored))
2202 return _forward_call(self->writer, &_Py_ID(flush), NULL);
2206 bufferedrwpair_readable(rwpair *self, PyObject *Py_UNUSED(ignored))
2208 return _forward_call(self->reader, &_Py_ID(readable), NULL);
2212 bufferedrwpair_writable(rwpair *self, PyObject *Py_UNUSED(ignored))
2214 return _forward_call(self->writer, &_Py_ID(writable), NULL);
2218 bufferedrwpair_close(rwpair *self, PyObject *Py_UNUSED(ignored))
2221 PyObject *ret = _forward_call(self->writer, &_Py_ID(close), NULL);
2226 ret = _forward_call(self->reader, &_Py_ID(close), NULL);
2235 bufferedrwpair_isatty(rwpair *self, PyObject *Py_UNUSED(ignored))
2237 PyObject *ret = _forward_call(self->writer, &_Py_ID(isatty), NULL);
2245 return _forward_call(self->reader, &_Py_ID(isatty), NULL);
2249 bufferedrwpair_closed_get(rwpair *self, void *context)
2251 if (self->writer == NULL) {
2256 return PyObject_GetAttr((PyObject *) self->writer, &_Py_ID(closed));
2279 _io_BufferedRandom___init___impl(buffered *self, PyObject *raw,
2283 self->ok = 0;
2284 self->detached = 0;
2294 Py_XSETREF(self->raw, raw);
2295 self->buffer_size = buffer_size;
2296 self->readable = 1;
2297 self->writable = 1;
2299 if (_buffered_init(self) < 0)
2301 _bufferedreader_reset_buf(self);
2302 _bufferedwriter_reset_buf(self);
2303 self->pos = 0;
2305 self->fast_closed_checks = (Py_IS_TYPE(self, &PyBufferedRandom_Type) &&
2308 self->ok = 1;