blob: d6f0c9cc83507f6026e794515b7da84ed2d64b47 [file] [log] [blame]
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001/*
2 An implementation of Buffered I/O as defined by PEP 3116 - "New I/O"
3
4 Classes defined here: BufferedIOBase, BufferedReader, BufferedWriter,
5 BufferedRandom.
6
7 Written by Amaury Forgeot d'Arc and Antoine Pitrou
8*/
9
10#define PY_SSIZE_T_CLEAN
11#include "Python.h"
12#include "structmember.h"
13#include "pythread.h"
14#include "_iomodule.h"
15
16/*
17 * BufferedIOBase class, inherits from IOBase.
18 */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +000019PyDoc_STRVAR(bufferediobase_doc,
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +000020 "Base class for buffered IO objects.\n"
21 "\n"
22 "The main difference with RawIOBase is that the read() method\n"
23 "supports omitting the size argument, and does not have a default\n"
24 "implementation that defers to readinto().\n"
25 "\n"
26 "In addition, read(), readinto() and write() may raise\n"
27 "BlockingIOError if the underlying raw stream is in non-blocking\n"
28 "mode and not ready; unlike their raw counterparts, they will never\n"
29 "return None.\n"
30 "\n"
31 "A typical implementation should not inherit from a RawIOBase\n"
32 "implementation, but wrap one.\n"
33 );
34
35static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +000036bufferediobase_readinto(PyObject *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +000037{
38 Py_buffer buf;
39 Py_ssize_t len;
40 PyObject *data;
41
42 if (!PyArg_ParseTuple(args, "w*:readinto", &buf)) {
43 return NULL;
44 }
45
46 data = PyObject_CallMethod(self, "read", "n", buf.len);
47 if (data == NULL)
48 goto error;
49
50 if (!PyBytes_Check(data)) {
51 Py_DECREF(data);
52 PyErr_SetString(PyExc_TypeError, "read() should return bytes");
53 goto error;
54 }
55
56 len = Py_SIZE(data);
57 memcpy(buf.buf, PyBytes_AS_STRING(data), len);
58
59 PyBuffer_Release(&buf);
60 Py_DECREF(data);
61
62 return PyLong_FromSsize_t(len);
63
64 error:
65 PyBuffer_Release(&buf);
66 return NULL;
67}
68
69static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +000070bufferediobase_unsupported(const char *message)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +000071{
72 PyErr_SetString(IO_STATE->unsupported_operation, message);
73 return NULL;
74}
75
Benjamin Peterson680bf1a2009-06-12 02:07:12 +000076PyDoc_STRVAR(bufferediobase_detach_doc,
Benjamin Petersond2e0c792009-05-01 20:40:59 +000077 "Disconnect this buffer from its underlying raw stream and return it.\n"
78 "\n"
79 "After the raw stream has been detached, the buffer is in an unusable\n"
80 "state.\n");
81
82static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +000083bufferediobase_detach(PyObject *self)
Benjamin Petersond2e0c792009-05-01 20:40:59 +000084{
Benjamin Peterson680bf1a2009-06-12 02:07:12 +000085 return bufferediobase_unsupported("detach");
Benjamin Petersond2e0c792009-05-01 20:40:59 +000086}
87
Benjamin Peterson680bf1a2009-06-12 02:07:12 +000088PyDoc_STRVAR(bufferediobase_read_doc,
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +000089 "Read and return up to n bytes.\n"
90 "\n"
91 "If the argument is omitted, None, or negative, reads and\n"
92 "returns all data until EOF.\n"
93 "\n"
94 "If the argument is positive, and the underlying raw stream is\n"
95 "not 'interactive', multiple raw reads may be issued to satisfy\n"
96 "the byte count (unless EOF is reached first). But for\n"
97 "interactive raw streams (as well as sockets and pipes), at most\n"
98 "one raw read will be issued, and a short result does not imply\n"
99 "that EOF is imminent.\n"
100 "\n"
101 "Returns an empty bytes object on EOF.\n"
102 "\n"
103 "Returns None if the underlying raw stream was open in non-blocking\n"
104 "mode and no data is available at the moment.\n");
105
106static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000107bufferediobase_read(PyObject *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000108{
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000109 return bufferediobase_unsupported("read");
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000110}
111
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000112PyDoc_STRVAR(bufferediobase_read1_doc,
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000113 "Read and return up to n bytes, with at most one read() call\n"
114 "to the underlying raw stream. A short result does not imply\n"
115 "that EOF is imminent.\n"
116 "\n"
117 "Returns an empty bytes object on EOF.\n");
118
119static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000120bufferediobase_read1(PyObject *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000121{
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000122 return bufferediobase_unsupported("read1");
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000123}
124
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000125PyDoc_STRVAR(bufferediobase_write_doc,
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000126 "Write the given buffer to the IO stream.\n"
127 "\n"
128 "Returns the number of bytes written, which is never less than\n"
129 "len(b).\n"
130 "\n"
131 "Raises BlockingIOError if the buffer is full and the\n"
132 "underlying raw stream cannot accept more data at the moment.\n");
133
134static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000135bufferediobase_write(PyObject *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000136{
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000137 return bufferediobase_unsupported("write");
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000138}
139
140
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000141static PyMethodDef bufferediobase_methods[] = {
142 {"detach", (PyCFunction)bufferediobase_detach, METH_NOARGS, bufferediobase_detach_doc},
143 {"read", bufferediobase_read, METH_VARARGS, bufferediobase_read_doc},
144 {"read1", bufferediobase_read1, METH_VARARGS, bufferediobase_read1_doc},
145 {"readinto", bufferediobase_readinto, METH_VARARGS, NULL},
146 {"write", bufferediobase_write, METH_VARARGS, bufferediobase_write_doc},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000147 {NULL, NULL}
148};
149
150PyTypeObject PyBufferedIOBase_Type = {
151 PyVarObject_HEAD_INIT(NULL, 0)
152 "_io._BufferedIOBase", /*tp_name*/
153 0, /*tp_basicsize*/
154 0, /*tp_itemsize*/
155 0, /*tp_dealloc*/
156 0, /*tp_print*/
157 0, /*tp_getattr*/
158 0, /*tp_setattr*/
159 0, /*tp_compare */
160 0, /*tp_repr*/
161 0, /*tp_as_number*/
162 0, /*tp_as_sequence*/
163 0, /*tp_as_mapping*/
164 0, /*tp_hash */
165 0, /*tp_call*/
166 0, /*tp_str*/
167 0, /*tp_getattro*/
168 0, /*tp_setattro*/
169 0, /*tp_as_buffer*/
170 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000171 bufferediobase_doc, /* tp_doc */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000172 0, /* tp_traverse */
173 0, /* tp_clear */
174 0, /* tp_richcompare */
175 0, /* tp_weaklistoffset */
176 0, /* tp_iter */
177 0, /* tp_iternext */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000178 bufferediobase_methods, /* tp_methods */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000179 0, /* tp_members */
180 0, /* tp_getset */
181 &PyIOBase_Type, /* tp_base */
182 0, /* tp_dict */
183 0, /* tp_descr_get */
184 0, /* tp_descr_set */
185 0, /* tp_dictoffset */
186 0, /* tp_init */
187 0, /* tp_alloc */
188 0, /* tp_new */
189};
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000190
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000191
192typedef struct {
193 PyObject_HEAD
194
195 PyObject *raw;
196 int ok; /* Initialized? */
Benjamin Petersond2e0c792009-05-01 20:40:59 +0000197 int detached;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000198 int readable;
199 int writable;
Antoine Pitroue033e062010-10-29 10:38:18 +0000200 int deallocating;
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000201
202 /* True if this is a vanilla Buffered object (rather than a user derived
203 class) *and* the raw stream is a vanilla FileIO object. */
204 int fast_closed_checks;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000205
206 /* Absolute position inside the raw stream (-1 if unknown). */
207 Py_off_t abs_pos;
208
209 /* A static buffer of size `buffer_size` */
210 char *buffer;
211 /* Current logical position in the buffer. */
212 Py_off_t pos;
213 /* Position of the raw stream in the buffer. */
214 Py_off_t raw_pos;
215
216 /* Just after the last buffered byte in the buffer, or -1 if the buffer
217 isn't ready for reading. */
218 Py_off_t read_end;
219
220 /* Just after the last byte actually written */
221 Py_off_t write_pos;
222 /* Just after the last byte waiting to be written, or -1 if the buffer
223 isn't ready for writing. */
224 Py_off_t write_end;
225
Georg Brandldfd73442009-04-05 11:47:34 +0000226#ifdef WITH_THREAD
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000227 PyThread_type_lock lock;
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000228 volatile long owner;
Georg Brandldfd73442009-04-05 11:47:34 +0000229#endif
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000230
231 Py_ssize_t buffer_size;
232 Py_ssize_t buffer_mask;
233
234 PyObject *dict;
235 PyObject *weakreflist;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000236} buffered;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000237
238/*
239 Implementation notes:
240
241 * BufferedReader, BufferedWriter and BufferedRandom try to share most
242 methods (this is helped by the members `readable` and `writable`, which
243 are initialized in the respective constructors)
244 * They also share a single buffer for reading and writing. This enables
245 interleaved reads and writes without flushing. It also makes the logic
246 a bit trickier to get right.
247 * The absolute position of the raw stream is cached, if possible, in the
248 `abs_pos` member. It must be updated every time an operation is done
249 on the raw stream. If not sure, it can be reinitialized by calling
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000250 _buffered_raw_tell(), which queries the raw stream (_buffered_raw_seek()
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000251 also does it). To read it, use RAW_TELL().
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000252 * Three helpers, _bufferedreader_raw_read, _bufferedwriter_raw_write and
253 _bufferedwriter_flush_unlocked do a lot of useful housekeeping.
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000254
255 NOTE: we should try to maintain block alignment of reads and writes to the
256 raw stream (according to the buffer size), but for now it is only done
257 in read() and friends.
258
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000259*/
260
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000261/* These macros protect the buffered object against concurrent operations. */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000262
Georg Brandldfd73442009-04-05 11:47:34 +0000263#ifdef WITH_THREAD
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000264
265static int
266_enter_buffered_busy(buffered *self)
267{
268 if (self->owner == PyThread_get_thread_ident()) {
269 PyErr_Format(PyExc_RuntimeError,
270 "reentrant call inside %R", self);
271 return 0;
Antoine Pitrou5800b272009-11-01 12:05:48 +0000272 }
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000273 Py_BEGIN_ALLOW_THREADS
274 PyThread_acquire_lock(self->lock, 1);
275 Py_END_ALLOW_THREADS
276 return 1;
277}
278
279#define ENTER_BUFFERED(self) \
280 ( (PyThread_acquire_lock(self->lock, 0) ? \
281 1 : _enter_buffered_busy(self)) \
282 && (self->owner = PyThread_get_thread_ident(), 1) )
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000283
284#define LEAVE_BUFFERED(self) \
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000285 do { \
286 self->owner = 0; \
287 PyThread_release_lock(self->lock); \
288 } while(0);
289
Georg Brandldfd73442009-04-05 11:47:34 +0000290#else
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000291#define ENTER_BUFFERED(self) 1
Georg Brandldfd73442009-04-05 11:47:34 +0000292#define LEAVE_BUFFERED(self)
293#endif
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000294
295#define CHECK_INITIALIZED(self) \
296 if (self->ok <= 0) { \
Benjamin Petersond2e0c792009-05-01 20:40:59 +0000297 if (self->detached) { \
298 PyErr_SetString(PyExc_ValueError, \
299 "raw stream has been detached"); \
300 } else { \
301 PyErr_SetString(PyExc_ValueError, \
302 "I/O operation on uninitialized object"); \
303 } \
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000304 return NULL; \
305 }
306
307#define CHECK_INITIALIZED_INT(self) \
308 if (self->ok <= 0) { \
Benjamin Petersond2e0c792009-05-01 20:40:59 +0000309 if (self->detached) { \
310 PyErr_SetString(PyExc_ValueError, \
311 "raw stream has been detached"); \
312 } else { \
313 PyErr_SetString(PyExc_ValueError, \
314 "I/O operation on uninitialized object"); \
315 } \
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000316 return -1; \
317 }
318
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000319#define IS_CLOSED(self) \
320 (self->fast_closed_checks \
321 ? _PyFileIO_closed(self->raw) \
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000322 : buffered_closed(self))
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000323
324#define CHECK_CLOSED(self, error_msg) \
325 if (IS_CLOSED(self)) { \
326 PyErr_SetString(PyExc_ValueError, error_msg); \
327 return NULL; \
328 }
329
330
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000331#define VALID_READ_BUFFER(self) \
332 (self->readable && self->read_end != -1)
333
334#define VALID_WRITE_BUFFER(self) \
335 (self->writable && self->write_end != -1)
336
337#define ADJUST_POSITION(self, _new_pos) \
338 do { \
339 self->pos = _new_pos; \
340 if (VALID_READ_BUFFER(self) && self->read_end < self->pos) \
341 self->read_end = self->pos; \
342 } while(0)
343
344#define READAHEAD(self) \
345 ((self->readable && VALID_READ_BUFFER(self)) \
346 ? (self->read_end - self->pos) : 0)
347
348#define RAW_OFFSET(self) \
349 (((VALID_READ_BUFFER(self) || VALID_WRITE_BUFFER(self)) \
350 && self->raw_pos >= 0) ? self->raw_pos - self->pos : 0)
351
352#define RAW_TELL(self) \
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000353 (self->abs_pos != -1 ? self->abs_pos : _buffered_raw_tell(self))
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000354
355#define MINUS_LAST_BLOCK(self, size) \
356 (self->buffer_mask ? \
357 (size & ~self->buffer_mask) : \
358 (self->buffer_size * (size / self->buffer_size)))
359
360
361static void
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000362buffered_dealloc(buffered *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000363{
Antoine Pitroue033e062010-10-29 10:38:18 +0000364 self->deallocating = 1;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000365 if (self->ok && _PyIOBase_finalize((PyObject *) self) < 0)
366 return;
367 _PyObject_GC_UNTRACK(self);
368 self->ok = 0;
369 if (self->weakreflist != NULL)
370 PyObject_ClearWeakRefs((PyObject *)self);
371 Py_CLEAR(self->raw);
372 if (self->buffer) {
373 PyMem_Free(self->buffer);
374 self->buffer = NULL;
375 }
Georg Brandldfd73442009-04-05 11:47:34 +0000376#ifdef WITH_THREAD
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000377 if (self->lock) {
378 PyThread_free_lock(self->lock);
379 self->lock = NULL;
380 }
Georg Brandldfd73442009-04-05 11:47:34 +0000381#endif
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000382 Py_CLEAR(self->dict);
383 Py_TYPE(self)->tp_free((PyObject *)self);
384}
385
386static int
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000387buffered_traverse(buffered *self, visitproc visit, void *arg)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000388{
389 Py_VISIT(self->raw);
390 Py_VISIT(self->dict);
391 return 0;
392}
393
394static int
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000395buffered_clear(buffered *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000396{
397 if (self->ok && _PyIOBase_finalize((PyObject *) self) < 0)
398 return -1;
399 self->ok = 0;
400 Py_CLEAR(self->raw);
401 Py_CLEAR(self->dict);
402 return 0;
403}
404
Antoine Pitroue033e062010-10-29 10:38:18 +0000405/* Because this can call arbitrary code, it shouldn't be called when
406 the refcount is 0 (that is, not directly from tp_dealloc unless
407 the refcount has been temporarily re-incremented). */
Matthias Klosebee33162010-11-16 20:07:51 +0000408static PyObject *
Antoine Pitroue033e062010-10-29 10:38:18 +0000409buffered_dealloc_warn(buffered *self, PyObject *source)
410{
411 if (self->ok && self->raw) {
412 PyObject *r;
413 r = PyObject_CallMethod(self->raw, "_dealloc_warn", "O", source);
414 if (r)
415 Py_DECREF(r);
416 else
417 PyErr_Clear();
418 }
419 Py_RETURN_NONE;
420}
421
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000422/*
423 * _BufferedIOMixin methods
424 * This is not a class, just a collection of methods that will be reused
425 * by BufferedReader and BufferedWriter
426 */
427
428/* Flush and close */
429
430static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000431buffered_simple_flush(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000432{
433 CHECK_INITIALIZED(self)
434 return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_flush, NULL);
435}
436
437static int
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000438buffered_closed(buffered *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000439{
440 int closed;
441 PyObject *res;
442 CHECK_INITIALIZED_INT(self)
443 res = PyObject_GetAttr(self->raw, _PyIO_str_closed);
444 if (res == NULL)
445 return -1;
446 closed = PyObject_IsTrue(res);
447 Py_DECREF(res);
448 return closed;
449}
450
451static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000452buffered_closed_get(buffered *self, void *context)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000453{
454 CHECK_INITIALIZED(self)
455 return PyObject_GetAttr(self->raw, _PyIO_str_closed);
456}
457
458static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000459buffered_close(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000460{
461 PyObject *res = NULL;
462 int r;
463
464 CHECK_INITIALIZED(self)
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000465 if (!ENTER_BUFFERED(self))
466 return NULL;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000467
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000468 r = buffered_closed(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000469 if (r < 0)
470 goto end;
471 if (r > 0) {
472 res = Py_None;
473 Py_INCREF(res);
474 goto end;
475 }
Antoine Pitroue033e062010-10-29 10:38:18 +0000476
477 if (self->deallocating) {
478 PyObject *r = buffered_dealloc_warn(self, (PyObject *) self);
479 if (r)
480 Py_DECREF(r);
481 else
482 PyErr_Clear();
483 }
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000484 /* flush() will most probably re-take the lock, so drop it first */
485 LEAVE_BUFFERED(self)
486 res = PyObject_CallMethodObjArgs((PyObject *)self, _PyIO_str_flush, NULL);
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000487 if (!ENTER_BUFFERED(self))
488 return NULL;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000489 if (res == NULL) {
Antoine Pitrou6be88762010-05-03 16:48:20 +0000490 goto end;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000491 }
492 Py_XDECREF(res);
493
494 res = PyObject_CallMethodObjArgs(self->raw, _PyIO_str_close, NULL);
495
496end:
497 LEAVE_BUFFERED(self)
498 return res;
499}
500
Benjamin Petersond2e0c792009-05-01 20:40:59 +0000501/* detach */
502
503static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000504buffered_detach(buffered *self, PyObject *args)
Benjamin Petersond2e0c792009-05-01 20:40:59 +0000505{
506 PyObject *raw, *res;
507 CHECK_INITIALIZED(self)
508 res = PyObject_CallMethodObjArgs((PyObject *)self, _PyIO_str_flush, NULL);
509 if (res == NULL)
510 return NULL;
511 Py_DECREF(res);
512 raw = self->raw;
513 self->raw = NULL;
514 self->detached = 1;
515 self->ok = 0;
516 return raw;
517}
518
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000519/* Inquiries */
520
521static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000522buffered_seekable(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000523{
524 CHECK_INITIALIZED(self)
525 return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_seekable, NULL);
526}
527
528static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000529buffered_readable(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000530{
531 CHECK_INITIALIZED(self)
532 return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_readable, NULL);
533}
534
535static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000536buffered_writable(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000537{
538 CHECK_INITIALIZED(self)
539 return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_writable, NULL);
540}
541
542static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000543buffered_name_get(buffered *self, void *context)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000544{
545 CHECK_INITIALIZED(self)
546 return PyObject_GetAttrString(self->raw, "name");
547}
548
549static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000550buffered_mode_get(buffered *self, void *context)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000551{
552 CHECK_INITIALIZED(self)
553 return PyObject_GetAttrString(self->raw, "mode");
554}
555
556/* Lower-level APIs */
557
558static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000559buffered_fileno(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000560{
561 CHECK_INITIALIZED(self)
562 return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_fileno, NULL);
563}
564
565static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000566buffered_isatty(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000567{
568 CHECK_INITIALIZED(self)
569 return PyObject_CallMethodObjArgs(self->raw, _PyIO_str_isatty, NULL);
570}
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000571
Antoine Pitrou243757e2010-11-05 21:15:39 +0000572/* Serialization */
573
574static PyObject *
575buffered_getstate(buffered *self, PyObject *args)
576{
577 PyErr_Format(PyExc_TypeError,
578 "cannot serialize '%s' object", Py_TYPE(self)->tp_name);
579 return NULL;
580}
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000581
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000582/* Forward decls */
583static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000584_bufferedwriter_flush_unlocked(buffered *, int);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000585static Py_ssize_t
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000586_bufferedreader_fill_buffer(buffered *self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000587static void
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000588_bufferedreader_reset_buf(buffered *self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000589static void
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000590_bufferedwriter_reset_buf(buffered *self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000591static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000592_bufferedreader_peek_unlocked(buffered *self, Py_ssize_t);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000593static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000594_bufferedreader_read_all(buffered *self);
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000595static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000596_bufferedreader_read_fast(buffered *self, Py_ssize_t);
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000597static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000598_bufferedreader_read_generic(buffered *self, Py_ssize_t);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000599
600
601/*
602 * Helpers
603 */
604
605/* Returns the address of the `written` member if a BlockingIOError was
606 raised, NULL otherwise. The error is always re-raised. */
607static Py_ssize_t *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000608_buffered_check_blocking_error(void)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000609{
610 PyObject *t, *v, *tb;
611 PyBlockingIOErrorObject *err;
612
613 PyErr_Fetch(&t, &v, &tb);
614 if (v == NULL || !PyErr_GivenExceptionMatches(v, PyExc_BlockingIOError)) {
615 PyErr_Restore(t, v, tb);
616 return NULL;
617 }
618 err = (PyBlockingIOErrorObject *) v;
619 /* TODO: sanity check (err->written >= 0) */
620 PyErr_Restore(t, v, tb);
621 return &err->written;
622}
623
624static Py_off_t
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000625_buffered_raw_tell(buffered *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000626{
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000627 Py_off_t n;
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000628 PyObject *res;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000629 res = PyObject_CallMethodObjArgs(self->raw, _PyIO_str_tell, NULL);
630 if (res == NULL)
631 return -1;
632 n = PyNumber_AsOff_t(res, PyExc_ValueError);
633 Py_DECREF(res);
634 if (n < 0) {
635 if (!PyErr_Occurred())
636 PyErr_Format(PyExc_IOError,
Mark Dickinson1a0aaaa2009-11-24 20:54:11 +0000637 "Raw stream returned invalid position %" PY_PRIdOFF,
638 (PY_OFF_T_COMPAT)n);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000639 return -1;
640 }
641 self->abs_pos = n;
642 return n;
643}
644
645static Py_off_t
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000646_buffered_raw_seek(buffered *self, Py_off_t target, int whence)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000647{
648 PyObject *res, *posobj, *whenceobj;
649 Py_off_t n;
650
651 posobj = PyLong_FromOff_t(target);
652 if (posobj == NULL)
653 return -1;
654 whenceobj = PyLong_FromLong(whence);
655 if (whenceobj == NULL) {
656 Py_DECREF(posobj);
657 return -1;
658 }
659 res = PyObject_CallMethodObjArgs(self->raw, _PyIO_str_seek,
660 posobj, whenceobj, NULL);
661 Py_DECREF(posobj);
662 Py_DECREF(whenceobj);
663 if (res == NULL)
664 return -1;
665 n = PyNumber_AsOff_t(res, PyExc_ValueError);
666 Py_DECREF(res);
667 if (n < 0) {
668 if (!PyErr_Occurred())
669 PyErr_Format(PyExc_IOError,
Mark Dickinson1a0aaaa2009-11-24 20:54:11 +0000670 "Raw stream returned invalid position %" PY_PRIdOFF,
671 (PY_OFF_T_COMPAT)n);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000672 return -1;
673 }
674 self->abs_pos = n;
675 return n;
676}
677
678static int
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000679_buffered_init(buffered *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000680{
681 Py_ssize_t n;
682 if (self->buffer_size <= 0) {
683 PyErr_SetString(PyExc_ValueError,
684 "buffer size must be strictly positive");
685 return -1;
686 }
687 if (self->buffer)
688 PyMem_Free(self->buffer);
689 self->buffer = PyMem_Malloc(self->buffer_size);
690 if (self->buffer == NULL) {
691 PyErr_NoMemory();
692 return -1;
693 }
Georg Brandldfd73442009-04-05 11:47:34 +0000694#ifdef WITH_THREAD
Antoine Pitrouc881f152010-08-01 16:53:42 +0000695 if (self->lock)
696 PyThread_free_lock(self->lock);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000697 self->lock = PyThread_allocate_lock();
698 if (self->lock == NULL) {
699 PyErr_SetString(PyExc_RuntimeError, "can't allocate read lock");
700 return -1;
701 }
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000702 self->owner = 0;
Georg Brandldfd73442009-04-05 11:47:34 +0000703#endif
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000704 /* Find out whether buffer_size is a power of 2 */
705 /* XXX is this optimization useful? */
706 for (n = self->buffer_size - 1; n & 1; n >>= 1)
707 ;
708 if (n == 0)
709 self->buffer_mask = self->buffer_size - 1;
710 else
711 self->buffer_mask = 0;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000712 if (_buffered_raw_tell(self) == -1)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000713 PyErr_Clear();
714 return 0;
715}
716
Antoine Pitroud843c2d2011-02-25 21:34:39 +0000717/* Return 1 if an EnvironmentError with errno == EINTR is set (and then
718 clears the error indicator), 0 otherwise.
719 Should only be called when PyErr_Occurred() is true.
720*/
721static int
722_trap_eintr(void)
723{
724 static PyObject *eintr_int = NULL;
725 PyObject *typ, *val, *tb;
726 PyEnvironmentErrorObject *env_err;
727
728 if (eintr_int == NULL) {
729 eintr_int = PyLong_FromLong(EINTR);
730 assert(eintr_int != NULL);
731 }
732 if (!PyErr_ExceptionMatches(PyExc_EnvironmentError))
733 return 0;
734 PyErr_Fetch(&typ, &val, &tb);
735 PyErr_NormalizeException(&typ, &val, &tb);
736 env_err = (PyEnvironmentErrorObject *) val;
737 assert(env_err != NULL);
738 if (env_err->myerrno != NULL &&
739 PyObject_RichCompareBool(env_err->myerrno, eintr_int, Py_EQ) > 0) {
740 Py_DECREF(typ);
741 Py_DECREF(val);
742 Py_XDECREF(tb);
743 return 1;
744 }
745 /* This silences any error set by PyObject_RichCompareBool() */
746 PyErr_Restore(typ, val, tb);
747 return 0;
748}
749
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000750/*
751 * Shared methods and wrappers
752 */
753
754static PyObject *
Antoine Pitroue05565e2011-08-20 14:39:23 +0200755buffered_flush_and_rewind_unlocked(buffered *self)
756{
757 PyObject *res;
758
759 res = _bufferedwriter_flush_unlocked(self, 0);
760 if (res == NULL)
761 return NULL;
762 Py_DECREF(res);
763
764 if (self->readable) {
765 /* Rewind the raw stream so that its position corresponds to
766 the current logical position. */
767 Py_off_t n;
768 n = _buffered_raw_seek(self, -RAW_OFFSET(self), 1);
769 _bufferedreader_reset_buf(self);
770 if (n == -1)
771 return NULL;
772 }
773 Py_RETURN_NONE;
774}
775
776static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000777buffered_flush(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000778{
779 PyObject *res;
780
781 CHECK_INITIALIZED(self)
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000782 CHECK_CLOSED(self, "flush of closed file")
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000783
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000784 if (!ENTER_BUFFERED(self))
785 return NULL;
Antoine Pitroue05565e2011-08-20 14:39:23 +0200786 res = buffered_flush_and_rewind_unlocked(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000787 LEAVE_BUFFERED(self)
788
789 return res;
790}
791
792static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000793buffered_peek(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000794{
795 Py_ssize_t n = 0;
796 PyObject *res = NULL;
797
798 CHECK_INITIALIZED(self)
799 if (!PyArg_ParseTuple(args, "|n:peek", &n)) {
800 return NULL;
801 }
802
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000803 if (!ENTER_BUFFERED(self))
804 return NULL;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000805
806 if (self->writable) {
Antoine Pitroue05565e2011-08-20 14:39:23 +0200807 res = buffered_flush_and_rewind_unlocked(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000808 if (res == NULL)
809 goto end;
810 Py_CLEAR(res);
811 }
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000812 res = _bufferedreader_peek_unlocked(self, n);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000813
814end:
815 LEAVE_BUFFERED(self)
816 return res;
817}
818
819static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000820buffered_read(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000821{
822 Py_ssize_t n = -1;
823 PyObject *res;
824
825 CHECK_INITIALIZED(self)
Benjamin Petersonbf5ff762009-12-13 19:25:34 +0000826 if (!PyArg_ParseTuple(args, "|O&:read", &_PyIO_ConvertSsize_t, &n)) {
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000827 return NULL;
828 }
829 if (n < -1) {
830 PyErr_SetString(PyExc_ValueError,
831 "read length must be positive or -1");
832 return NULL;
833 }
834
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000835 CHECK_CLOSED(self, "read of closed file")
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000836
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000837 if (n == -1) {
838 /* The number of bytes is unspecified, read until the end of stream */
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000839 if (!ENTER_BUFFERED(self))
840 return NULL;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000841 res = _bufferedreader_read_all(self);
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000842 }
843 else {
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000844 res = _bufferedreader_read_fast(self, n);
Antoine Pitroue05565e2011-08-20 14:39:23 +0200845 if (res != Py_None)
846 return res;
847 Py_DECREF(res);
848 if (!ENTER_BUFFERED(self))
849 return NULL;
850 res = _bufferedreader_read_generic(self, n);
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000851 }
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000852
Antoine Pitroue05565e2011-08-20 14:39:23 +0200853 LEAVE_BUFFERED(self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000854 return res;
855}
856
857static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000858buffered_read1(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000859{
860 Py_ssize_t n, have, r;
861 PyObject *res = NULL;
862
863 CHECK_INITIALIZED(self)
864 if (!PyArg_ParseTuple(args, "n:read1", &n)) {
865 return NULL;
866 }
867
868 if (n < 0) {
869 PyErr_SetString(PyExc_ValueError,
870 "read length must be positive");
871 return NULL;
872 }
873 if (n == 0)
874 return PyBytes_FromStringAndSize(NULL, 0);
875
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000876 if (!ENTER_BUFFERED(self))
877 return NULL;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000878
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000879 /* Return up to n bytes. If at least one byte is buffered, we
880 only return buffered bytes. Otherwise, we do one raw read. */
881
882 /* XXX: this mimicks the io.py implementation but is probably wrong.
883 If we need to read from the raw stream, then we could actually read
884 all `n` bytes asked by the caller (and possibly more, so as to fill
885 our buffer for the next reads). */
886
887 have = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
888 if (have > 0) {
889 if (n > have)
890 n = have;
891 res = PyBytes_FromStringAndSize(self->buffer + self->pos, n);
892 if (res == NULL)
893 goto end;
894 self->pos += n;
895 goto end;
896 }
897
Antoine Pitroue05565e2011-08-20 14:39:23 +0200898 if (self->writable) {
899 res = buffered_flush_and_rewind_unlocked(self);
900 if (res == NULL)
901 goto end;
902 Py_DECREF(res);
903 }
904
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000905 /* Fill the buffer from the raw stream, and copy it to the result. */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000906 _bufferedreader_reset_buf(self);
907 r = _bufferedreader_fill_buffer(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000908 if (r == -1)
909 goto end;
910 if (r == -2)
911 r = 0;
912 if (n > r)
913 n = r;
914 res = PyBytes_FromStringAndSize(self->buffer, n);
915 if (res == NULL)
916 goto end;
917 self->pos = n;
918
919end:
920 LEAVE_BUFFERED(self)
921 return res;
922}
923
924static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000925buffered_readinto(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000926{
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000927 CHECK_INITIALIZED(self)
928
Antoine Pitroue05565e2011-08-20 14:39:23 +0200929 /* TODO: use raw.readinto() (or a direct copy from our buffer) instead! */
930 return bufferediobase_readinto((PyObject *)self, args);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000931}
932
933static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000934_buffered_readline(buffered *self, Py_ssize_t limit)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000935{
936 PyObject *res = NULL;
937 PyObject *chunks = NULL;
938 Py_ssize_t n, written = 0;
939 const char *start, *s, *end;
940
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000941 CHECK_CLOSED(self, "readline of closed file")
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000942
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000943 /* First, try to find a line in the buffer. This can run unlocked because
944 the calls to the C API are simple enough that they can't trigger
945 any thread switch. */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000946 n = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
947 if (limit >= 0 && n > limit)
948 n = limit;
949 start = self->buffer + self->pos;
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000950 s = memchr(start, '\n', n);
951 if (s != NULL) {
952 res = PyBytes_FromStringAndSize(start, s - start + 1);
953 if (res != NULL)
954 self->pos += s - start + 1;
955 goto end_unlocked;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000956 }
957 if (n == limit) {
958 res = PyBytes_FromStringAndSize(start, n);
959 if (res != NULL)
960 self->pos += n;
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000961 goto end_unlocked;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000962 }
963
Antoine Pitrouf3b68b32010-12-03 18:41:39 +0000964 if (!ENTER_BUFFERED(self))
965 goto end_unlocked;
Antoine Pitrou711af3a2009-04-11 15:39:24 +0000966
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000967 /* Now we try to get some more from the raw stream */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000968 chunks = PyList_New(0);
969 if (chunks == NULL)
970 goto end;
971 if (n > 0) {
972 res = PyBytes_FromStringAndSize(start, n);
973 if (res == NULL)
974 goto end;
975 if (PyList_Append(chunks, res) < 0) {
976 Py_CLEAR(res);
977 goto end;
978 }
979 Py_CLEAR(res);
980 written += n;
Antoine Pitroue05565e2011-08-20 14:39:23 +0200981 self->pos += n;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000982 if (limit >= 0)
983 limit -= n;
984 }
Antoine Pitroue05565e2011-08-20 14:39:23 +0200985 if (self->writable) {
986 PyObject *r = buffered_flush_and_rewind_unlocked(self);
987 if (r == NULL)
988 goto end;
989 Py_DECREF(r);
990 }
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000991
992 for (;;) {
Benjamin Peterson680bf1a2009-06-12 02:07:12 +0000993 _bufferedreader_reset_buf(self);
994 n = _bufferedreader_fill_buffer(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +0000995 if (n == -1)
996 goto end;
997 if (n <= 0)
998 break;
999 if (limit >= 0 && n > limit)
1000 n = limit;
1001 start = self->buffer;
1002 end = start + n;
1003 s = start;
1004 while (s < end) {
1005 if (*s++ == '\n') {
1006 res = PyBytes_FromStringAndSize(start, s - start);
1007 if (res == NULL)
1008 goto end;
1009 self->pos = s - start;
1010 goto found;
1011 }
1012 }
1013 res = PyBytes_FromStringAndSize(start, n);
1014 if (res == NULL)
1015 goto end;
1016 if (n == limit) {
1017 self->pos = n;
1018 break;
1019 }
1020 if (PyList_Append(chunks, res) < 0) {
1021 Py_CLEAR(res);
1022 goto end;
1023 }
1024 Py_CLEAR(res);
1025 written += n;
1026 if (limit >= 0)
1027 limit -= n;
1028 }
1029found:
1030 if (res != NULL && PyList_Append(chunks, res) < 0) {
1031 Py_CLEAR(res);
1032 goto end;
1033 }
1034 Py_CLEAR(res);
1035 res = _PyBytes_Join(_PyIO_empty_bytes, chunks);
1036
1037end:
1038 LEAVE_BUFFERED(self)
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001039end_unlocked:
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001040 Py_XDECREF(chunks);
1041 return res;
1042}
1043
1044static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001045buffered_readline(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001046{
1047 Py_ssize_t limit = -1;
1048
1049 CHECK_INITIALIZED(self)
Benjamin Petersonbf5ff762009-12-13 19:25:34 +00001050 if (!PyArg_ParseTuple(args, "|O&:readline", &_PyIO_ConvertSsize_t, &limit))
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001051 return NULL;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001052 return _buffered_readline(self, limit);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001053}
1054
1055
1056static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001057buffered_tell(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001058{
1059 Py_off_t pos;
1060
1061 CHECK_INITIALIZED(self)
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001062 pos = _buffered_raw_tell(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001063 if (pos == -1)
1064 return NULL;
1065 pos -= RAW_OFFSET(self);
1066 /* TODO: sanity check (pos >= 0) */
1067 return PyLong_FromOff_t(pos);
1068}
1069
1070static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001071buffered_seek(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001072{
1073 Py_off_t target, n;
1074 int whence = 0;
1075 PyObject *targetobj, *res = NULL;
1076
1077 CHECK_INITIALIZED(self)
1078 if (!PyArg_ParseTuple(args, "O|i:seek", &targetobj, &whence)) {
1079 return NULL;
1080 }
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001081 if (whence < 0 || whence > 2) {
1082 PyErr_Format(PyExc_ValueError,
1083 "whence must be between 0 and 2, not %d", whence);
1084 return NULL;
1085 }
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001086
1087 CHECK_CLOSED(self, "seek of closed file")
1088
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001089 target = PyNumber_AsOff_t(targetobj, PyExc_ValueError);
1090 if (target == -1 && PyErr_Occurred())
1091 return NULL;
1092
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001093 if (whence != 2 && self->readable) {
1094 Py_off_t current, avail;
1095 /* Check if seeking leaves us inside the current buffer,
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001096 so as to return quickly if possible. Also, we needn't take the
1097 lock in this fast path.
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001098 Don't know how to do that when whence == 2, though. */
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001099 /* NOTE: RAW_TELL() can release the GIL but the object is in a stable
1100 state at this point. */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001101 current = RAW_TELL(self);
1102 avail = READAHEAD(self);
1103 if (avail > 0) {
1104 Py_off_t offset;
1105 if (whence == 0)
1106 offset = target - (current - RAW_OFFSET(self));
1107 else
1108 offset = target;
1109 if (offset >= -self->pos && offset <= avail) {
1110 self->pos += offset;
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001111 return PyLong_FromOff_t(current - avail + offset);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001112 }
1113 }
1114 }
1115
Antoine Pitrouf3b68b32010-12-03 18:41:39 +00001116 if (!ENTER_BUFFERED(self))
1117 return NULL;
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001118
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001119 /* Fallback: invoke raw seek() method and clear buffer */
1120 if (self->writable) {
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001121 res = _bufferedwriter_flush_unlocked(self, 0);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001122 if (res == NULL)
1123 goto end;
1124 Py_CLEAR(res);
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001125 _bufferedwriter_reset_buf(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001126 }
1127
1128 /* TODO: align on block boundary and read buffer if needed? */
1129 if (whence == 1)
1130 target -= RAW_OFFSET(self);
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001131 n = _buffered_raw_seek(self, target, whence);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001132 if (n == -1)
1133 goto end;
1134 self->raw_pos = -1;
1135 res = PyLong_FromOff_t(n);
1136 if (res != NULL && self->readable)
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001137 _bufferedreader_reset_buf(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001138
1139end:
1140 LEAVE_BUFFERED(self)
1141 return res;
1142}
1143
1144static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001145buffered_truncate(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001146{
1147 PyObject *pos = Py_None;
1148 PyObject *res = NULL;
1149
1150 CHECK_INITIALIZED(self)
1151 if (!PyArg_ParseTuple(args, "|O:truncate", &pos)) {
1152 return NULL;
1153 }
1154
Antoine Pitrouf3b68b32010-12-03 18:41:39 +00001155 if (!ENTER_BUFFERED(self))
1156 return NULL;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001157
1158 if (self->writable) {
Antoine Pitroue05565e2011-08-20 14:39:23 +02001159 res = buffered_flush_and_rewind_unlocked(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001160 if (res == NULL)
1161 goto end;
1162 Py_CLEAR(res);
1163 }
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001164 res = PyObject_CallMethodObjArgs(self->raw, _PyIO_str_truncate, pos, NULL);
1165 if (res == NULL)
1166 goto end;
1167 /* Reset cached position */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001168 if (_buffered_raw_tell(self) == -1)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001169 PyErr_Clear();
1170
1171end:
1172 LEAVE_BUFFERED(self)
1173 return res;
1174}
1175
1176static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001177buffered_iternext(buffered *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001178{
1179 PyObject *line;
1180 PyTypeObject *tp;
1181
1182 CHECK_INITIALIZED(self);
1183
1184 tp = Py_TYPE(self);
1185 if (tp == &PyBufferedReader_Type ||
1186 tp == &PyBufferedRandom_Type) {
1187 /* Skip method call overhead for speed */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001188 line = _buffered_readline(self, -1);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001189 }
1190 else {
1191 line = PyObject_CallMethodObjArgs((PyObject *)self,
1192 _PyIO_str_readline, NULL);
1193 if (line && !PyBytes_Check(line)) {
1194 PyErr_Format(PyExc_IOError,
1195 "readline() should have returned a bytes object, "
1196 "not '%.200s'", Py_TYPE(line)->tp_name);
1197 Py_DECREF(line);
1198 return NULL;
1199 }
1200 }
1201
1202 if (line == NULL)
1203 return NULL;
1204
1205 if (PyBytes_GET_SIZE(line) == 0) {
1206 /* Reached EOF or would have blocked */
1207 Py_DECREF(line);
1208 return NULL;
1209 }
1210
1211 return line;
1212}
1213
Antoine Pitrou716c4442009-05-23 19:04:03 +00001214static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001215buffered_repr(buffered *self)
Antoine Pitrou716c4442009-05-23 19:04:03 +00001216{
1217 PyObject *nameobj, *res;
1218
1219 nameobj = PyObject_GetAttrString((PyObject *) self, "name");
1220 if (nameobj == NULL) {
1221 if (PyErr_ExceptionMatches(PyExc_AttributeError))
1222 PyErr_Clear();
1223 else
1224 return NULL;
1225 res = PyUnicode_FromFormat("<%s>", Py_TYPE(self)->tp_name);
1226 }
1227 else {
1228 res = PyUnicode_FromFormat("<%s name=%R>",
1229 Py_TYPE(self)->tp_name, nameobj);
1230 Py_DECREF(nameobj);
1231 }
1232 return res;
1233}
1234
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001235/*
1236 * class BufferedReader
1237 */
1238
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001239PyDoc_STRVAR(bufferedreader_doc,
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001240 "Create a new buffered reader using the given readable raw IO object.");
1241
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001242static void _bufferedreader_reset_buf(buffered *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001243{
1244 self->read_end = -1;
1245}
1246
1247static int
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001248bufferedreader_init(buffered *self, PyObject *args, PyObject *kwds)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001249{
1250 char *kwlist[] = {"raw", "buffer_size", NULL};
1251 Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
1252 PyObject *raw;
1253
1254 self->ok = 0;
Benjamin Petersond2e0c792009-05-01 20:40:59 +00001255 self->detached = 0;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001256
1257 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|n:BufferedReader", kwlist,
1258 &raw, &buffer_size)) {
1259 return -1;
1260 }
1261
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001262 if (_PyIOBase_check_readable(raw, Py_True) == NULL)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001263 return -1;
1264
1265 Py_CLEAR(self->raw);
1266 Py_INCREF(raw);
1267 self->raw = raw;
1268 self->buffer_size = buffer_size;
1269 self->readable = 1;
1270 self->writable = 0;
1271
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001272 if (_buffered_init(self) < 0)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001273 return -1;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001274 _bufferedreader_reset_buf(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001275
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001276 self->fast_closed_checks = (Py_TYPE(self) == &PyBufferedReader_Type &&
1277 Py_TYPE(raw) == &PyFileIO_Type);
1278
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001279 self->ok = 1;
1280 return 0;
1281}
1282
1283static Py_ssize_t
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001284_bufferedreader_raw_read(buffered *self, char *start, Py_ssize_t len)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001285{
1286 Py_buffer buf;
1287 PyObject *memobj, *res;
1288 Py_ssize_t n;
1289 /* NOTE: the buffer needn't be released as its object is NULL. */
1290 if (PyBuffer_FillInfo(&buf, NULL, start, len, 0, PyBUF_CONTIG) == -1)
1291 return -1;
1292 memobj = PyMemoryView_FromBuffer(&buf);
1293 if (memobj == NULL)
1294 return -1;
Antoine Pitroud843c2d2011-02-25 21:34:39 +00001295 /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() when EINTR
1296 occurs so we needn't do it ourselves.
1297 We then retry reading, ignoring the signal if no handler has
1298 raised (see issue #10956).
1299 */
1300 do {
1301 res = PyObject_CallMethodObjArgs(self->raw, _PyIO_str_readinto, memobj, NULL);
1302 } while (res == NULL && _trap_eintr());
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001303 Py_DECREF(memobj);
1304 if (res == NULL)
1305 return -1;
1306 if (res == Py_None) {
1307 /* Non-blocking stream would have blocked. Special return code! */
1308 Py_DECREF(res);
1309 return -2;
1310 }
1311 n = PyNumber_AsSsize_t(res, PyExc_ValueError);
1312 Py_DECREF(res);
1313 if (n < 0 || n > len) {
1314 PyErr_Format(PyExc_IOError,
1315 "raw readinto() returned invalid length %zd "
1316 "(should have been between 0 and %zd)", n, len);
1317 return -1;
1318 }
1319 if (n > 0 && self->abs_pos != -1)
1320 self->abs_pos += n;
1321 return n;
1322}
1323
1324static Py_ssize_t
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001325_bufferedreader_fill_buffer(buffered *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001326{
1327 Py_ssize_t start, len, n;
1328 if (VALID_READ_BUFFER(self))
1329 start = Py_SAFE_DOWNCAST(self->read_end, Py_off_t, Py_ssize_t);
1330 else
1331 start = 0;
1332 len = self->buffer_size - start;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001333 n = _bufferedreader_raw_read(self, self->buffer + start, len);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001334 if (n <= 0)
1335 return n;
1336 self->read_end = start + n;
1337 self->raw_pos = start + n;
1338 return n;
1339}
1340
1341static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001342_bufferedreader_read_all(buffered *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001343{
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001344 Py_ssize_t current_size;
1345 PyObject *res, *data = NULL;
1346 PyObject *chunks = PyList_New(0);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001347
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001348 if (chunks == NULL)
1349 return NULL;
1350
1351 /* First copy what we have in the current buffer. */
1352 current_size = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
1353 if (current_size) {
1354 data = PyBytes_FromStringAndSize(
1355 self->buffer + self->pos, current_size);
1356 if (data == NULL) {
1357 Py_DECREF(chunks);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001358 return NULL;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001359 }
Antoine Pitroue05565e2011-08-20 14:39:23 +02001360 self->pos += current_size;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001361 }
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001362 /* We're going past the buffer's bounds, flush it */
1363 if (self->writable) {
Antoine Pitroue05565e2011-08-20 14:39:23 +02001364 res = buffered_flush_and_rewind_unlocked(self);
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001365 if (res == NULL) {
1366 Py_DECREF(chunks);
1367 return NULL;
1368 }
1369 Py_CLEAR(res);
1370 }
Antoine Pitroue05565e2011-08-20 14:39:23 +02001371 _bufferedreader_reset_buf(self);
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001372 while (1) {
1373 if (data) {
1374 if (PyList_Append(chunks, data) < 0) {
1375 Py_DECREF(data);
1376 Py_DECREF(chunks);
1377 return NULL;
1378 }
1379 Py_DECREF(data);
1380 }
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001381
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001382 /* Read until EOF or until read() would block. */
1383 data = PyObject_CallMethodObjArgs(self->raw, _PyIO_str_read, NULL);
1384 if (data == NULL) {
1385 Py_DECREF(chunks);
1386 return NULL;
1387 }
1388 if (data != Py_None && !PyBytes_Check(data)) {
1389 Py_DECREF(data);
1390 Py_DECREF(chunks);
1391 PyErr_SetString(PyExc_TypeError, "read() should return bytes");
1392 return NULL;
1393 }
1394 if (data == Py_None || PyBytes_GET_SIZE(data) == 0) {
1395 if (current_size == 0) {
1396 Py_DECREF(chunks);
1397 return data;
1398 }
1399 else {
1400 res = _PyBytes_Join(_PyIO_empty_bytes, chunks);
1401 Py_DECREF(data);
1402 Py_DECREF(chunks);
1403 return res;
1404 }
1405 }
1406 current_size += PyBytes_GET_SIZE(data);
1407 if (self->abs_pos != -1)
1408 self->abs_pos += PyBytes_GET_SIZE(data);
1409 }
1410}
1411
1412/* Read n bytes from the buffer if it can, otherwise return None.
1413 This function is simple enough that it can run unlocked. */
1414static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001415_bufferedreader_read_fast(buffered *self, Py_ssize_t n)
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001416{
1417 Py_ssize_t current_size;
1418
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001419 current_size = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
1420 if (n <= current_size) {
1421 /* Fast path: the data to read is fully buffered. */
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001422 PyObject *res = PyBytes_FromStringAndSize(self->buffer + self->pos, n);
1423 if (res != NULL)
1424 self->pos += n;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001425 return res;
1426 }
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001427 Py_RETURN_NONE;
1428}
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001429
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001430/* Generic read function: read from the stream until enough bytes are read,
1431 * or until an EOF occurs or until read() would block.
1432 */
1433static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001434_bufferedreader_read_generic(buffered *self, Py_ssize_t n)
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001435{
1436 PyObject *res = NULL;
1437 Py_ssize_t current_size, remaining, written;
1438 char *out;
1439
1440 current_size = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
1441 if (n <= current_size)
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001442 return _bufferedreader_read_fast(self, n);
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001443
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001444 res = PyBytes_FromStringAndSize(NULL, n);
1445 if (res == NULL)
1446 goto error;
1447 out = PyBytes_AS_STRING(res);
1448 remaining = n;
1449 written = 0;
1450 if (current_size > 0) {
1451 memcpy(out, self->buffer + self->pos, current_size);
1452 remaining -= current_size;
1453 written += current_size;
Antoine Pitroue05565e2011-08-20 14:39:23 +02001454 self->pos += current_size;
1455 }
1456 /* Flush the write buffer if necessary */
1457 if (self->writable) {
1458 PyObject *r = buffered_flush_and_rewind_unlocked(self);
1459 if (r == NULL)
1460 goto error;
1461 Py_DECREF(r);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001462 }
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001463 _bufferedreader_reset_buf(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001464 while (remaining > 0) {
1465 /* We want to read a whole block at the end into buffer.
1466 If we had readv() we could do this in one pass. */
1467 Py_ssize_t r = MINUS_LAST_BLOCK(self, remaining);
1468 if (r == 0)
1469 break;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001470 r = _bufferedreader_raw_read(self, out + written, r);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001471 if (r == -1)
1472 goto error;
1473 if (r == 0 || r == -2) {
1474 /* EOF occurred or read() would block. */
1475 if (r == 0 || written > 0) {
1476 if (_PyBytes_Resize(&res, written))
1477 goto error;
1478 return res;
1479 }
1480 Py_DECREF(res);
1481 Py_INCREF(Py_None);
1482 return Py_None;
1483 }
1484 remaining -= r;
1485 written += r;
1486 }
1487 assert(remaining <= self->buffer_size);
1488 self->pos = 0;
1489 self->raw_pos = 0;
1490 self->read_end = 0;
Antoine Pitrou32cfede2010-08-11 13:31:33 +00001491 /* NOTE: when the read is satisfied, we avoid issuing any additional
1492 reads, which could block indefinitely (e.g. on a socket).
1493 See issue #9550. */
1494 while (remaining > 0 && self->read_end < self->buffer_size) {
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001495 Py_ssize_t r = _bufferedreader_fill_buffer(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001496 if (r == -1)
1497 goto error;
1498 if (r == 0 || r == -2) {
1499 /* EOF occurred or read() would block. */
1500 if (r == 0 || written > 0) {
1501 if (_PyBytes_Resize(&res, written))
1502 goto error;
1503 return res;
1504 }
1505 Py_DECREF(res);
1506 Py_INCREF(Py_None);
1507 return Py_None;
1508 }
1509 if (remaining > r) {
1510 memcpy(out + written, self->buffer + self->pos, r);
1511 written += r;
1512 self->pos += r;
1513 remaining -= r;
1514 }
1515 else if (remaining > 0) {
1516 memcpy(out + written, self->buffer + self->pos, remaining);
1517 written += remaining;
1518 self->pos += remaining;
1519 remaining = 0;
1520 }
1521 if (remaining == 0)
1522 break;
1523 }
1524
1525 return res;
1526
1527error:
1528 Py_XDECREF(res);
1529 return NULL;
1530}
1531
1532static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001533_bufferedreader_peek_unlocked(buffered *self, Py_ssize_t n)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001534{
1535 Py_ssize_t have, r;
1536
1537 have = Py_SAFE_DOWNCAST(READAHEAD(self), Py_off_t, Py_ssize_t);
1538 /* Constraints:
1539 1. we don't want to advance the file position.
1540 2. we don't want to lose block alignment, so we can't shift the buffer
1541 to make some place.
1542 Therefore, we either return `have` bytes (if > 0), or a full buffer.
1543 */
1544 if (have > 0) {
1545 return PyBytes_FromStringAndSize(self->buffer + self->pos, have);
1546 }
1547
1548 /* Fill the buffer from the raw stream, and copy it to the result. */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001549 _bufferedreader_reset_buf(self);
1550 r = _bufferedreader_fill_buffer(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001551 if (r == -1)
1552 return NULL;
1553 if (r == -2)
1554 r = 0;
1555 self->pos = 0;
1556 return PyBytes_FromStringAndSize(self->buffer, r);
1557}
1558
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001559static PyMethodDef bufferedreader_methods[] = {
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001560 /* BufferedIOMixin methods */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001561 {"detach", (PyCFunction)buffered_detach, METH_NOARGS},
1562 {"flush", (PyCFunction)buffered_simple_flush, METH_NOARGS},
1563 {"close", (PyCFunction)buffered_close, METH_NOARGS},
1564 {"seekable", (PyCFunction)buffered_seekable, METH_NOARGS},
1565 {"readable", (PyCFunction)buffered_readable, METH_NOARGS},
1566 {"writable", (PyCFunction)buffered_writable, METH_NOARGS},
1567 {"fileno", (PyCFunction)buffered_fileno, METH_NOARGS},
1568 {"isatty", (PyCFunction)buffered_isatty, METH_NOARGS},
Antoine Pitroue033e062010-10-29 10:38:18 +00001569 {"_dealloc_warn", (PyCFunction)buffered_dealloc_warn, METH_O},
Antoine Pitrou243757e2010-11-05 21:15:39 +00001570 {"__getstate__", (PyCFunction)buffered_getstate, METH_NOARGS},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001571
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001572 {"read", (PyCFunction)buffered_read, METH_VARARGS},
1573 {"peek", (PyCFunction)buffered_peek, METH_VARARGS},
1574 {"read1", (PyCFunction)buffered_read1, METH_VARARGS},
1575 {"readline", (PyCFunction)buffered_readline, METH_VARARGS},
1576 {"seek", (PyCFunction)buffered_seek, METH_VARARGS},
1577 {"tell", (PyCFunction)buffered_tell, METH_NOARGS},
1578 {"truncate", (PyCFunction)buffered_truncate, METH_VARARGS},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001579 {NULL, NULL}
1580};
1581
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001582static PyMemberDef bufferedreader_members[] = {
Antoine Pitrou7f8f4182010-12-21 21:20:59 +00001583 {"raw", T_OBJECT, offsetof(buffered, raw), READONLY},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001584 {NULL}
1585};
1586
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001587static PyGetSetDef bufferedreader_getset[] = {
1588 {"closed", (getter)buffered_closed_get, NULL, NULL},
1589 {"name", (getter)buffered_name_get, NULL, NULL},
1590 {"mode", (getter)buffered_mode_get, NULL, NULL},
Benjamin Peterson1fea3212009-04-19 03:15:20 +00001591 {NULL}
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001592};
1593
1594
1595PyTypeObject PyBufferedReader_Type = {
1596 PyVarObject_HEAD_INIT(NULL, 0)
1597 "_io.BufferedReader", /*tp_name*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001598 sizeof(buffered), /*tp_basicsize*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001599 0, /*tp_itemsize*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001600 (destructor)buffered_dealloc, /*tp_dealloc*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001601 0, /*tp_print*/
1602 0, /*tp_getattr*/
1603 0, /*tp_setattr*/
1604 0, /*tp_compare */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001605 (reprfunc)buffered_repr, /*tp_repr*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001606 0, /*tp_as_number*/
1607 0, /*tp_as_sequence*/
1608 0, /*tp_as_mapping*/
1609 0, /*tp_hash */
1610 0, /*tp_call*/
1611 0, /*tp_str*/
1612 0, /*tp_getattro*/
1613 0, /*tp_setattro*/
1614 0, /*tp_as_buffer*/
1615 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
1616 | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001617 bufferedreader_doc, /* tp_doc */
1618 (traverseproc)buffered_traverse, /* tp_traverse */
1619 (inquiry)buffered_clear, /* tp_clear */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001620 0, /* tp_richcompare */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001621 offsetof(buffered, weakreflist), /*tp_weaklistoffset*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001622 0, /* tp_iter */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001623 (iternextfunc)buffered_iternext, /* tp_iternext */
1624 bufferedreader_methods, /* tp_methods */
1625 bufferedreader_members, /* tp_members */
1626 bufferedreader_getset, /* tp_getset */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001627 0, /* tp_base */
1628 0, /* tp_dict */
1629 0, /* tp_descr_get */
1630 0, /* tp_descr_set */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001631 offsetof(buffered, dict), /* tp_dictoffset */
1632 (initproc)bufferedreader_init, /* tp_init */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001633 0, /* tp_alloc */
1634 PyType_GenericNew, /* tp_new */
1635};
1636
1637
Benjamin Peterson59406a92009-03-26 17:10:29 +00001638
1639static int
1640complain_about_max_buffer_size(void)
1641{
1642 if (PyErr_WarnEx(PyExc_DeprecationWarning,
1643 "max_buffer_size is deprecated", 1) < 0)
1644 return 0;
1645 return 1;
1646}
1647
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001648/*
1649 * class BufferedWriter
1650 */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001651PyDoc_STRVAR(bufferedwriter_doc,
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001652 "A buffer for a writeable sequential RawIO object.\n"
1653 "\n"
1654 "The constructor creates a BufferedWriter for the given writeable raw\n"
1655 "stream. If the buffer_size is not given, it defaults to\n"
1656 "DEFAULT_BUFFER_SIZE. max_buffer_size isn't used anymore.\n"
1657 );
1658
1659static void
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001660_bufferedwriter_reset_buf(buffered *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001661{
1662 self->write_pos = 0;
1663 self->write_end = -1;
1664}
1665
1666static int
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001667bufferedwriter_init(buffered *self, PyObject *args, PyObject *kwds)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001668{
1669 /* TODO: properly deprecate max_buffer_size */
1670 char *kwlist[] = {"raw", "buffer_size", "max_buffer_size", NULL};
1671 Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
Benjamin Peterson59406a92009-03-26 17:10:29 +00001672 Py_ssize_t max_buffer_size = -234;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001673 PyObject *raw;
1674
1675 self->ok = 0;
Benjamin Petersond2e0c792009-05-01 20:40:59 +00001676 self->detached = 0;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001677
1678 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|nn:BufferedReader", kwlist,
1679 &raw, &buffer_size, &max_buffer_size)) {
1680 return -1;
1681 }
1682
Benjamin Peterson59406a92009-03-26 17:10:29 +00001683 if (max_buffer_size != -234 && !complain_about_max_buffer_size())
1684 return -1;
1685
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001686 if (_PyIOBase_check_writable(raw, Py_True) == NULL)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001687 return -1;
1688
1689 Py_CLEAR(self->raw);
1690 Py_INCREF(raw);
1691 self->raw = raw;
1692 self->readable = 0;
1693 self->writable = 1;
1694
1695 self->buffer_size = buffer_size;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001696 if (_buffered_init(self) < 0)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001697 return -1;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001698 _bufferedwriter_reset_buf(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001699 self->pos = 0;
1700
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001701 self->fast_closed_checks = (Py_TYPE(self) == &PyBufferedWriter_Type &&
1702 Py_TYPE(raw) == &PyFileIO_Type);
1703
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001704 self->ok = 1;
1705 return 0;
1706}
1707
1708static Py_ssize_t
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001709_bufferedwriter_raw_write(buffered *self, char *start, Py_ssize_t len)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001710{
1711 Py_buffer buf;
1712 PyObject *memobj, *res;
1713 Py_ssize_t n;
1714 /* NOTE: the buffer needn't be released as its object is NULL. */
1715 if (PyBuffer_FillInfo(&buf, NULL, start, len, 1, PyBUF_CONTIG_RO) == -1)
1716 return -1;
1717 memobj = PyMemoryView_FromBuffer(&buf);
1718 if (memobj == NULL)
1719 return -1;
Antoine Pitroud843c2d2011-02-25 21:34:39 +00001720 /* NOTE: PyErr_SetFromErrno() calls PyErr_CheckSignals() when EINTR
1721 occurs so we needn't do it ourselves.
1722 We then retry writing, ignoring the signal if no handler has
1723 raised (see issue #10956).
1724 */
1725 do {
1726 res = PyObject_CallMethodObjArgs(self->raw, _PyIO_str_write, memobj, NULL);
1727 } while (res == NULL && _trap_eintr());
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001728 Py_DECREF(memobj);
1729 if (res == NULL)
1730 return -1;
1731 n = PyNumber_AsSsize_t(res, PyExc_ValueError);
1732 Py_DECREF(res);
1733 if (n < 0 || n > len) {
1734 PyErr_Format(PyExc_IOError,
1735 "raw write() returned invalid length %zd "
1736 "(should have been between 0 and %zd)", n, len);
1737 return -1;
1738 }
1739 if (n > 0 && self->abs_pos != -1)
1740 self->abs_pos += n;
1741 return n;
1742}
1743
1744/* `restore_pos` is 1 if we need to restore the raw stream position at
1745 the end, 0 otherwise. */
1746static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001747_bufferedwriter_flush_unlocked(buffered *self, int restore_pos)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001748{
1749 Py_ssize_t written = 0;
1750 Py_off_t n, rewind;
1751
1752 if (!VALID_WRITE_BUFFER(self) || self->write_pos == self->write_end)
1753 goto end;
1754 /* First, rewind */
1755 rewind = RAW_OFFSET(self) + (self->pos - self->write_pos);
1756 if (rewind != 0) {
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001757 n = _buffered_raw_seek(self, -rewind, 1);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001758 if (n < 0) {
1759 goto error;
1760 }
1761 self->raw_pos -= rewind;
1762 }
1763 while (self->write_pos < self->write_end) {
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001764 n = _bufferedwriter_raw_write(self,
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001765 self->buffer + self->write_pos,
1766 Py_SAFE_DOWNCAST(self->write_end - self->write_pos,
1767 Py_off_t, Py_ssize_t));
1768 if (n == -1) {
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001769 Py_ssize_t *w = _buffered_check_blocking_error();
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001770 if (w == NULL)
1771 goto error;
1772 self->write_pos += *w;
1773 self->raw_pos = self->write_pos;
1774 written += *w;
1775 *w = written;
1776 /* Already re-raised */
1777 goto error;
1778 }
1779 self->write_pos += n;
1780 self->raw_pos = self->write_pos;
1781 written += Py_SAFE_DOWNCAST(n, Py_off_t, Py_ssize_t);
Antoine Pitroub46b9d52010-08-21 19:09:32 +00001782 /* Partial writes can return successfully when interrupted by a
1783 signal (see write(2)). We must run signal handlers before
1784 blocking another time, possibly indefinitely. */
1785 if (PyErr_CheckSignals() < 0)
1786 goto error;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001787 }
1788
1789 if (restore_pos) {
1790 Py_off_t forward = rewind - written;
1791 if (forward != 0) {
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001792 n = _buffered_raw_seek(self, forward, 1);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001793 if (n < 0) {
1794 goto error;
1795 }
1796 self->raw_pos += forward;
1797 }
1798 }
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001799 _bufferedwriter_reset_buf(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001800
1801end:
1802 Py_RETURN_NONE;
1803
1804error:
1805 return NULL;
1806}
1807
1808static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001809bufferedwriter_write(buffered *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001810{
1811 PyObject *res = NULL;
1812 Py_buffer buf;
Amaury Forgeot d'Arce1b60d42009-10-05 21:09:00 +00001813 Py_ssize_t written, avail, remaining;
1814 Py_off_t offset;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001815
1816 CHECK_INITIALIZED(self)
1817 if (!PyArg_ParseTuple(args, "y*:write", &buf)) {
1818 return NULL;
1819 }
1820
Antoine Pitrou711af3a2009-04-11 15:39:24 +00001821 if (IS_CLOSED(self)) {
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001822 PyErr_SetString(PyExc_ValueError, "write to closed file");
1823 PyBuffer_Release(&buf);
1824 return NULL;
1825 }
1826
Antoine Pitrouf3b68b32010-12-03 18:41:39 +00001827 if (!ENTER_BUFFERED(self)) {
1828 PyBuffer_Release(&buf);
1829 return NULL;
1830 }
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001831
1832 /* Fast path: the data to write can be fully buffered. */
1833 if (!VALID_READ_BUFFER(self) && !VALID_WRITE_BUFFER(self)) {
1834 self->pos = 0;
1835 self->raw_pos = 0;
1836 }
1837 avail = Py_SAFE_DOWNCAST(self->buffer_size - self->pos, Py_off_t, Py_ssize_t);
1838 if (buf.len <= avail) {
1839 memcpy(self->buffer + self->pos, buf.buf, buf.len);
Antoine Pitrou7c404892011-05-13 00:13:33 +02001840 if (!VALID_WRITE_BUFFER(self) || self->write_pos > self->pos) {
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001841 self->write_pos = self->pos;
1842 }
1843 ADJUST_POSITION(self, self->pos + buf.len);
1844 if (self->pos > self->write_end)
1845 self->write_end = self->pos;
1846 written = buf.len;
1847 goto end;
1848 }
1849
1850 /* First write the current buffer */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001851 res = _bufferedwriter_flush_unlocked(self, 0);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001852 if (res == NULL) {
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001853 Py_ssize_t *w = _buffered_check_blocking_error();
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001854 if (w == NULL)
1855 goto error;
1856 if (self->readable)
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001857 _bufferedreader_reset_buf(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001858 /* Make some place by shifting the buffer. */
1859 assert(VALID_WRITE_BUFFER(self));
1860 memmove(self->buffer, self->buffer + self->write_pos,
1861 Py_SAFE_DOWNCAST(self->write_end - self->write_pos,
1862 Py_off_t, Py_ssize_t));
1863 self->write_end -= self->write_pos;
1864 self->raw_pos -= self->write_pos;
1865 self->pos -= self->write_pos;
1866 self->write_pos = 0;
1867 avail = Py_SAFE_DOWNCAST(self->buffer_size - self->write_end,
1868 Py_off_t, Py_ssize_t);
1869 if (buf.len <= avail) {
1870 /* Everything can be buffered */
1871 PyErr_Clear();
1872 memcpy(self->buffer + self->write_end, buf.buf, buf.len);
1873 self->write_end += buf.len;
1874 written = buf.len;
1875 goto end;
1876 }
1877 /* Buffer as much as possible. */
1878 memcpy(self->buffer + self->write_end, buf.buf, avail);
1879 self->write_end += avail;
1880 /* Already re-raised */
1881 *w = avail;
1882 goto error;
1883 }
1884 Py_CLEAR(res);
1885
Antoine Pitroua0ceb732009-08-06 20:29:56 +00001886 /* Adjust the raw stream position if it is away from the logical stream
1887 position. This happens if the read buffer has been filled but not
1888 modified (and therefore _bufferedwriter_flush_unlocked() didn't rewind
1889 the raw stream by itself).
1890 Fixes issue #6629.
1891 */
Amaury Forgeot d'Arce1b60d42009-10-05 21:09:00 +00001892 offset = RAW_OFFSET(self);
1893 if (offset != 0) {
1894 if (_buffered_raw_seek(self, -offset, 1) < 0)
Antoine Pitroua0ceb732009-08-06 20:29:56 +00001895 goto error;
Amaury Forgeot d'Arce1b60d42009-10-05 21:09:00 +00001896 self->raw_pos -= offset;
Antoine Pitroua0ceb732009-08-06 20:29:56 +00001897 }
1898
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001899 /* Then write buf itself. At this point the buffer has been emptied. */
1900 remaining = buf.len;
1901 written = 0;
1902 while (remaining > self->buffer_size) {
Amaury Forgeot d'Arce1b60d42009-10-05 21:09:00 +00001903 Py_ssize_t n = _bufferedwriter_raw_write(
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001904 self, (char *) buf.buf + written, buf.len - written);
1905 if (n == -1) {
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001906 Py_ssize_t *w = _buffered_check_blocking_error();
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001907 if (w == NULL)
1908 goto error;
1909 written += *w;
1910 remaining -= *w;
1911 if (remaining > self->buffer_size) {
1912 /* Can't buffer everything, still buffer as much as possible */
1913 memcpy(self->buffer,
1914 (char *) buf.buf + written, self->buffer_size);
1915 self->raw_pos = 0;
1916 ADJUST_POSITION(self, self->buffer_size);
1917 self->write_end = self->buffer_size;
1918 *w = written + self->buffer_size;
1919 /* Already re-raised */
1920 goto error;
1921 }
1922 PyErr_Clear();
1923 break;
1924 }
1925 written += n;
1926 remaining -= n;
Antoine Pitroub46b9d52010-08-21 19:09:32 +00001927 /* Partial writes can return successfully when interrupted by a
1928 signal (see write(2)). We must run signal handlers before
1929 blocking another time, possibly indefinitely. */
1930 if (PyErr_CheckSignals() < 0)
1931 goto error;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001932 }
1933 if (self->readable)
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001934 _bufferedreader_reset_buf(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001935 if (remaining > 0) {
1936 memcpy(self->buffer, (char *) buf.buf + written, remaining);
1937 written += remaining;
1938 }
1939 self->write_pos = 0;
1940 /* TODO: sanity check (remaining >= 0) */
1941 self->write_end = remaining;
1942 ADJUST_POSITION(self, remaining);
1943 self->raw_pos = 0;
1944
1945end:
1946 res = PyLong_FromSsize_t(written);
1947
1948error:
1949 LEAVE_BUFFERED(self)
1950 PyBuffer_Release(&buf);
1951 return res;
1952}
1953
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001954static PyMethodDef bufferedwriter_methods[] = {
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001955 /* BufferedIOMixin methods */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001956 {"close", (PyCFunction)buffered_close, METH_NOARGS},
1957 {"detach", (PyCFunction)buffered_detach, METH_NOARGS},
1958 {"seekable", (PyCFunction)buffered_seekable, METH_NOARGS},
1959 {"readable", (PyCFunction)buffered_readable, METH_NOARGS},
1960 {"writable", (PyCFunction)buffered_writable, METH_NOARGS},
1961 {"fileno", (PyCFunction)buffered_fileno, METH_NOARGS},
1962 {"isatty", (PyCFunction)buffered_isatty, METH_NOARGS},
Antoine Pitroue033e062010-10-29 10:38:18 +00001963 {"_dealloc_warn", (PyCFunction)buffered_dealloc_warn, METH_O},
Antoine Pitrou243757e2010-11-05 21:15:39 +00001964 {"__getstate__", (PyCFunction)buffered_getstate, METH_NOARGS},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001965
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001966 {"write", (PyCFunction)bufferedwriter_write, METH_VARARGS},
1967 {"truncate", (PyCFunction)buffered_truncate, METH_VARARGS},
1968 {"flush", (PyCFunction)buffered_flush, METH_NOARGS},
1969 {"seek", (PyCFunction)buffered_seek, METH_VARARGS},
1970 {"tell", (PyCFunction)buffered_tell, METH_NOARGS},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001971 {NULL, NULL}
1972};
1973
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001974static PyMemberDef bufferedwriter_members[] = {
Antoine Pitrou7f8f4182010-12-21 21:20:59 +00001975 {"raw", T_OBJECT, offsetof(buffered, raw), READONLY},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001976 {NULL}
1977};
1978
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001979static PyGetSetDef bufferedwriter_getset[] = {
1980 {"closed", (getter)buffered_closed_get, NULL, NULL},
1981 {"name", (getter)buffered_name_get, NULL, NULL},
1982 {"mode", (getter)buffered_mode_get, NULL, NULL},
Benjamin Peterson1fea3212009-04-19 03:15:20 +00001983 {NULL}
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001984};
1985
1986
1987PyTypeObject PyBufferedWriter_Type = {
1988 PyVarObject_HEAD_INIT(NULL, 0)
1989 "_io.BufferedWriter", /*tp_name*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001990 sizeof(buffered), /*tp_basicsize*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001991 0, /*tp_itemsize*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001992 (destructor)buffered_dealloc, /*tp_dealloc*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001993 0, /*tp_print*/
1994 0, /*tp_getattr*/
1995 0, /*tp_setattr*/
1996 0, /*tp_compare */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00001997 (reprfunc)buffered_repr, /*tp_repr*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00001998 0, /*tp_as_number*/
1999 0, /*tp_as_sequence*/
2000 0, /*tp_as_mapping*/
2001 0, /*tp_hash */
2002 0, /*tp_call*/
2003 0, /*tp_str*/
2004 0, /*tp_getattro*/
2005 0, /*tp_setattro*/
2006 0, /*tp_as_buffer*/
2007 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
2008 | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002009 bufferedwriter_doc, /* tp_doc */
2010 (traverseproc)buffered_traverse, /* tp_traverse */
2011 (inquiry)buffered_clear, /* tp_clear */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002012 0, /* tp_richcompare */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002013 offsetof(buffered, weakreflist), /*tp_weaklistoffset*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002014 0, /* tp_iter */
2015 0, /* tp_iternext */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002016 bufferedwriter_methods, /* tp_methods */
2017 bufferedwriter_members, /* tp_members */
2018 bufferedwriter_getset, /* tp_getset */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002019 0, /* tp_base */
2020 0, /* tp_dict */
2021 0, /* tp_descr_get */
2022 0, /* tp_descr_set */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002023 offsetof(buffered, dict), /* tp_dictoffset */
2024 (initproc)bufferedwriter_init, /* tp_init */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002025 0, /* tp_alloc */
2026 PyType_GenericNew, /* tp_new */
2027};
2028
2029
2030
2031/*
2032 * BufferedRWPair
2033 */
2034
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002035PyDoc_STRVAR(bufferedrwpair_doc,
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002036 "A buffered reader and writer object together.\n"
2037 "\n"
2038 "A buffered reader object and buffered writer object put together to\n"
2039 "form a sequential IO object that can read and write. This is typically\n"
2040 "used with a socket or two-way pipe.\n"
2041 "\n"
2042 "reader and writer are RawIOBase objects that are readable and\n"
2043 "writeable respectively. If the buffer_size is omitted it defaults to\n"
Benjamin Peterson59406a92009-03-26 17:10:29 +00002044 "DEFAULT_BUFFER_SIZE.\n"
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002045 );
2046
2047/* XXX The usefulness of this (compared to having two separate IO objects) is
2048 * questionable.
2049 */
2050
2051typedef struct {
2052 PyObject_HEAD
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002053 buffered *reader;
2054 buffered *writer;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002055 PyObject *dict;
2056 PyObject *weakreflist;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002057} rwpair;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002058
2059static int
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002060bufferedrwpair_init(rwpair *self, PyObject *args, PyObject *kwds)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002061{
2062 PyObject *reader, *writer;
2063 Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
Benjamin Peterson59406a92009-03-26 17:10:29 +00002064 Py_ssize_t max_buffer_size = -234;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002065
2066 if (!PyArg_ParseTuple(args, "OO|nn:BufferedRWPair", &reader, &writer,
2067 &buffer_size, &max_buffer_size)) {
2068 return -1;
2069 }
2070
Benjamin Peterson59406a92009-03-26 17:10:29 +00002071 if (max_buffer_size != -234 && !complain_about_max_buffer_size())
2072 return -1;
2073
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002074 if (_PyIOBase_check_readable(reader, Py_True) == NULL)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002075 return -1;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002076 if (_PyIOBase_check_writable(writer, Py_True) == NULL)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002077 return -1;
2078
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002079 self->reader = (buffered *) PyObject_CallFunction(
Antoine Pitroucf4c7492009-04-19 00:09:36 +00002080 (PyObject *) &PyBufferedReader_Type, "On", reader, buffer_size);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002081 if (self->reader == NULL)
2082 return -1;
2083
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002084 self->writer = (buffered *) PyObject_CallFunction(
Antoine Pitroucf4c7492009-04-19 00:09:36 +00002085 (PyObject *) &PyBufferedWriter_Type, "On", writer, buffer_size);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002086 if (self->writer == NULL) {
2087 Py_CLEAR(self->reader);
2088 return -1;
2089 }
Antoine Pitroucf4c7492009-04-19 00:09:36 +00002090
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002091 return 0;
2092}
2093
2094static int
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002095bufferedrwpair_traverse(rwpair *self, visitproc visit, void *arg)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002096{
2097 Py_VISIT(self->dict);
2098 return 0;
2099}
2100
2101static int
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002102bufferedrwpair_clear(rwpair *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002103{
2104 Py_CLEAR(self->reader);
2105 Py_CLEAR(self->writer);
2106 Py_CLEAR(self->dict);
2107 return 0;
2108}
2109
2110static void
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002111bufferedrwpair_dealloc(rwpair *self)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002112{
2113 _PyObject_GC_UNTRACK(self);
2114 Py_CLEAR(self->reader);
2115 Py_CLEAR(self->writer);
2116 Py_CLEAR(self->dict);
2117 Py_TYPE(self)->tp_free((PyObject *) self);
2118}
2119
2120static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002121_forward_call(buffered *self, const char *name, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002122{
2123 PyObject *func = PyObject_GetAttrString((PyObject *)self, name);
2124 PyObject *ret;
2125
2126 if (func == NULL) {
2127 PyErr_SetString(PyExc_AttributeError, name);
2128 return NULL;
2129 }
2130
2131 ret = PyObject_CallObject(func, args);
2132 Py_DECREF(func);
2133 return ret;
2134}
2135
2136static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002137bufferedrwpair_read(rwpair *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002138{
2139 return _forward_call(self->reader, "read", args);
2140}
2141
2142static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002143bufferedrwpair_peek(rwpair *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002144{
2145 return _forward_call(self->reader, "peek", args);
2146}
2147
2148static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002149bufferedrwpair_read1(rwpair *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002150{
2151 return _forward_call(self->reader, "read1", args);
2152}
2153
2154static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002155bufferedrwpair_readinto(rwpair *self, PyObject *args)
Antoine Pitroucf4c7492009-04-19 00:09:36 +00002156{
2157 return _forward_call(self->reader, "readinto", args);
2158}
2159
2160static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002161bufferedrwpair_write(rwpair *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002162{
2163 return _forward_call(self->writer, "write", args);
2164}
2165
2166static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002167bufferedrwpair_flush(rwpair *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002168{
2169 return _forward_call(self->writer, "flush", args);
2170}
2171
2172static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002173bufferedrwpair_readable(rwpair *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002174{
2175 return _forward_call(self->reader, "readable", args);
2176}
2177
2178static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002179bufferedrwpair_writable(rwpair *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002180{
2181 return _forward_call(self->writer, "writable", args);
2182}
2183
2184static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002185bufferedrwpair_close(rwpair *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002186{
2187 PyObject *ret = _forward_call(self->writer, "close", args);
2188 if (ret == NULL)
2189 return NULL;
2190 Py_DECREF(ret);
2191
2192 return _forward_call(self->reader, "close", args);
2193}
2194
2195static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002196bufferedrwpair_isatty(rwpair *self, PyObject *args)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002197{
2198 PyObject *ret = _forward_call(self->writer, "isatty", args);
2199
2200 if (ret != Py_False) {
2201 /* either True or exception */
2202 return ret;
2203 }
2204 Py_DECREF(ret);
2205
2206 return _forward_call(self->reader, "isatty", args);
2207}
2208
Antoine Pitroucf4c7492009-04-19 00:09:36 +00002209static PyObject *
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002210bufferedrwpair_closed_get(rwpair *self, void *context)
Antoine Pitroucf4c7492009-04-19 00:09:36 +00002211{
2212 return PyObject_GetAttr((PyObject *) self->writer, _PyIO_str_closed);
2213}
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002214
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002215static PyMethodDef bufferedrwpair_methods[] = {
2216 {"read", (PyCFunction)bufferedrwpair_read, METH_VARARGS},
2217 {"peek", (PyCFunction)bufferedrwpair_peek, METH_VARARGS},
2218 {"read1", (PyCFunction)bufferedrwpair_read1, METH_VARARGS},
2219 {"readinto", (PyCFunction)bufferedrwpair_readinto, METH_VARARGS},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002220
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002221 {"write", (PyCFunction)bufferedrwpair_write, METH_VARARGS},
2222 {"flush", (PyCFunction)bufferedrwpair_flush, METH_NOARGS},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002223
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002224 {"readable", (PyCFunction)bufferedrwpair_readable, METH_NOARGS},
2225 {"writable", (PyCFunction)bufferedrwpair_writable, METH_NOARGS},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002226
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002227 {"close", (PyCFunction)bufferedrwpair_close, METH_NOARGS},
2228 {"isatty", (PyCFunction)bufferedrwpair_isatty, METH_NOARGS},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002229
Antoine Pitrou243757e2010-11-05 21:15:39 +00002230 {"__getstate__", (PyCFunction)buffered_getstate, METH_NOARGS},
2231
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002232 {NULL, NULL}
2233};
2234
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002235static PyGetSetDef bufferedrwpair_getset[] = {
2236 {"closed", (getter)bufferedrwpair_closed_get, NULL, NULL},
Benjamin Peterson1fea3212009-04-19 03:15:20 +00002237 {NULL}
Antoine Pitroucf4c7492009-04-19 00:09:36 +00002238};
2239
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002240PyTypeObject PyBufferedRWPair_Type = {
2241 PyVarObject_HEAD_INIT(NULL, 0)
2242 "_io.BufferedRWPair", /*tp_name*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002243 sizeof(rwpair), /*tp_basicsize*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002244 0, /*tp_itemsize*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002245 (destructor)bufferedrwpair_dealloc, /*tp_dealloc*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002246 0, /*tp_print*/
2247 0, /*tp_getattr*/
2248 0, /*tp_setattr*/
2249 0, /*tp_compare */
2250 0, /*tp_repr*/
2251 0, /*tp_as_number*/
2252 0, /*tp_as_sequence*/
2253 0, /*tp_as_mapping*/
2254 0, /*tp_hash */
2255 0, /*tp_call*/
2256 0, /*tp_str*/
2257 0, /*tp_getattro*/
2258 0, /*tp_setattro*/
2259 0, /*tp_as_buffer*/
2260 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
2261 | Py_TPFLAGS_HAVE_GC, /* tp_flags */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002262 bufferedrwpair_doc, /* tp_doc */
2263 (traverseproc)bufferedrwpair_traverse, /* tp_traverse */
2264 (inquiry)bufferedrwpair_clear, /* tp_clear */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002265 0, /* tp_richcompare */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002266 offsetof(rwpair, weakreflist), /*tp_weaklistoffset*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002267 0, /* tp_iter */
2268 0, /* tp_iternext */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002269 bufferedrwpair_methods, /* tp_methods */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002270 0, /* tp_members */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002271 bufferedrwpair_getset, /* tp_getset */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002272 0, /* tp_base */
2273 0, /* tp_dict */
2274 0, /* tp_descr_get */
2275 0, /* tp_descr_set */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002276 offsetof(rwpair, dict), /* tp_dictoffset */
2277 (initproc)bufferedrwpair_init, /* tp_init */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002278 0, /* tp_alloc */
2279 PyType_GenericNew, /* tp_new */
2280};
2281
2282
2283
2284/*
2285 * BufferedRandom
2286 */
2287
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002288PyDoc_STRVAR(bufferedrandom_doc,
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002289 "A buffered interface to random access streams.\n"
2290 "\n"
2291 "The constructor creates a reader and writer for a seekable stream,\n"
2292 "raw, given in the first argument. If the buffer_size is omitted it\n"
2293 "defaults to DEFAULT_BUFFER_SIZE. max_buffer_size isn't used anymore.\n"
2294 );
2295
2296static int
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002297bufferedrandom_init(buffered *self, PyObject *args, PyObject *kwds)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002298{
2299 char *kwlist[] = {"raw", "buffer_size", "max_buffer_size", NULL};
2300 Py_ssize_t buffer_size = DEFAULT_BUFFER_SIZE;
Benjamin Peterson59406a92009-03-26 17:10:29 +00002301 Py_ssize_t max_buffer_size = -234;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002302 PyObject *raw;
2303
2304 self->ok = 0;
Benjamin Petersond2e0c792009-05-01 20:40:59 +00002305 self->detached = 0;
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002306
2307 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|nn:BufferedReader", kwlist,
2308 &raw, &buffer_size, &max_buffer_size)) {
2309 return -1;
2310 }
2311
Benjamin Peterson59406a92009-03-26 17:10:29 +00002312 if (max_buffer_size != -234 && !complain_about_max_buffer_size())
2313 return -1;
2314
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002315 if (_PyIOBase_check_seekable(raw, Py_True) == NULL)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002316 return -1;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002317 if (_PyIOBase_check_readable(raw, Py_True) == NULL)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002318 return -1;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002319 if (_PyIOBase_check_writable(raw, Py_True) == NULL)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002320 return -1;
2321
2322 Py_CLEAR(self->raw);
2323 Py_INCREF(raw);
2324 self->raw = raw;
2325 self->buffer_size = buffer_size;
2326 self->readable = 1;
2327 self->writable = 1;
2328
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002329 if (_buffered_init(self) < 0)
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002330 return -1;
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002331 _bufferedreader_reset_buf(self);
2332 _bufferedwriter_reset_buf(self);
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002333 self->pos = 0;
2334
Antoine Pitrou711af3a2009-04-11 15:39:24 +00002335 self->fast_closed_checks = (Py_TYPE(self) == &PyBufferedRandom_Type &&
2336 Py_TYPE(raw) == &PyFileIO_Type);
2337
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002338 self->ok = 1;
2339 return 0;
2340}
2341
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002342static PyMethodDef bufferedrandom_methods[] = {
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002343 /* BufferedIOMixin methods */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002344 {"close", (PyCFunction)buffered_close, METH_NOARGS},
2345 {"detach", (PyCFunction)buffered_detach, METH_NOARGS},
2346 {"seekable", (PyCFunction)buffered_seekable, METH_NOARGS},
2347 {"readable", (PyCFunction)buffered_readable, METH_NOARGS},
2348 {"writable", (PyCFunction)buffered_writable, METH_NOARGS},
2349 {"fileno", (PyCFunction)buffered_fileno, METH_NOARGS},
2350 {"isatty", (PyCFunction)buffered_isatty, METH_NOARGS},
Antoine Pitroue033e062010-10-29 10:38:18 +00002351 {"_dealloc_warn", (PyCFunction)buffered_dealloc_warn, METH_O},
Antoine Pitrou243757e2010-11-05 21:15:39 +00002352 {"__getstate__", (PyCFunction)buffered_getstate, METH_NOARGS},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002353
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002354 {"flush", (PyCFunction)buffered_flush, METH_NOARGS},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002355
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002356 {"seek", (PyCFunction)buffered_seek, METH_VARARGS},
2357 {"tell", (PyCFunction)buffered_tell, METH_NOARGS},
2358 {"truncate", (PyCFunction)buffered_truncate, METH_VARARGS},
2359 {"read", (PyCFunction)buffered_read, METH_VARARGS},
2360 {"read1", (PyCFunction)buffered_read1, METH_VARARGS},
2361 {"readinto", (PyCFunction)buffered_readinto, METH_VARARGS},
2362 {"readline", (PyCFunction)buffered_readline, METH_VARARGS},
2363 {"peek", (PyCFunction)buffered_peek, METH_VARARGS},
2364 {"write", (PyCFunction)bufferedwriter_write, METH_VARARGS},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002365 {NULL, NULL}
2366};
2367
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002368static PyMemberDef bufferedrandom_members[] = {
Antoine Pitrou7f8f4182010-12-21 21:20:59 +00002369 {"raw", T_OBJECT, offsetof(buffered, raw), READONLY},
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002370 {NULL}
2371};
2372
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002373static PyGetSetDef bufferedrandom_getset[] = {
2374 {"closed", (getter)buffered_closed_get, NULL, NULL},
2375 {"name", (getter)buffered_name_get, NULL, NULL},
2376 {"mode", (getter)buffered_mode_get, NULL, NULL},
Benjamin Peterson1fea3212009-04-19 03:15:20 +00002377 {NULL}
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002378};
2379
2380
2381PyTypeObject PyBufferedRandom_Type = {
2382 PyVarObject_HEAD_INIT(NULL, 0)
2383 "_io.BufferedRandom", /*tp_name*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002384 sizeof(buffered), /*tp_basicsize*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002385 0, /*tp_itemsize*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002386 (destructor)buffered_dealloc, /*tp_dealloc*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002387 0, /*tp_print*/
2388 0, /*tp_getattr*/
2389 0, /*tp_setattr*/
2390 0, /*tp_compare */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002391 (reprfunc)buffered_repr, /*tp_repr*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002392 0, /*tp_as_number*/
2393 0, /*tp_as_sequence*/
2394 0, /*tp_as_mapping*/
2395 0, /*tp_hash */
2396 0, /*tp_call*/
2397 0, /*tp_str*/
2398 0, /*tp_getattro*/
2399 0, /*tp_setattro*/
2400 0, /*tp_as_buffer*/
2401 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
2402 | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002403 bufferedrandom_doc, /* tp_doc */
2404 (traverseproc)buffered_traverse, /* tp_traverse */
2405 (inquiry)buffered_clear, /* tp_clear */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002406 0, /* tp_richcompare */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002407 offsetof(buffered, weakreflist), /*tp_weaklistoffset*/
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002408 0, /* tp_iter */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002409 (iternextfunc)buffered_iternext, /* tp_iternext */
2410 bufferedrandom_methods, /* tp_methods */
2411 bufferedrandom_members, /* tp_members */
2412 bufferedrandom_getset, /* tp_getset */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002413 0, /* tp_base */
2414 0, /*tp_dict*/
2415 0, /* tp_descr_get */
2416 0, /* tp_descr_set */
Benjamin Peterson680bf1a2009-06-12 02:07:12 +00002417 offsetof(buffered, dict), /*tp_dictoffset*/
2418 (initproc)bufferedrandom_init, /* tp_init */
Benjamin Peterson4fa88fa2009-03-04 00:14:51 +00002419 0, /* tp_alloc */
2420 PyType_GenericNew, /* tp_new */
2421};