No issues found
1 #include "Python.h"
2 #include "structmember.h" /* for offsetof() */
3 #include "_iomodule.h"
4
5 typedef struct {
6 PyObject_HEAD
7 char *buf;
8 Py_ssize_t pos;
9 Py_ssize_t string_size;
10 size_t buf_size;
11 PyObject *dict;
12 PyObject *weakreflist;
13 } bytesio;
14
15 #define CHECK_CLOSED(self) \
16 if ((self)->buf == NULL) { \
17 PyErr_SetString(PyExc_ValueError, \
18 "I/O operation on closed file."); \
19 return NULL; \
20 }
21
22 /* Internal routine to get a line from the buffer of a BytesIO
23 object. Returns the length between the current position to the
24 next newline character. */
25 static Py_ssize_t
26 get_line(bytesio *self, char **output)
27 {
28 char *n;
29 const char *str_end;
30 Py_ssize_t len;
31
32 assert(self->buf != NULL);
33
34 /* Move to the end of the line, up to the end of the string, s. */
35 str_end = self->buf + self->string_size;
36 for (n = self->buf + self->pos;
37 n < str_end && *n != '\n';
38 n++);
39
40 /* Skip the newline character */
41 if (n < str_end)
42 n++;
43
44 /* Get the length from the current position to the end of the line. */
45 len = n - (self->buf + self->pos);
46 *output = self->buf + self->pos;
47
48 assert(len >= 0);
49 assert(self->pos < PY_SSIZE_T_MAX - len);
50 self->pos += len;
51
52 return len;
53 }
54
55 /* Internal routine for changing the size of the buffer of BytesIO objects.
56 The caller should ensure that the 'size' argument is non-negative. Returns
57 0 on success, -1 otherwise. */
58 static int
59 resize_buffer(bytesio *self, size_t size)
60 {
61 /* Here, unsigned types are used to avoid dealing with signed integer
62 overflow, which is undefined in C. */
63 size_t alloc = self->buf_size;
64 char *new_buf = NULL;
65
66 assert(self->buf != NULL);
67
68 /* For simplicity, stay in the range of the signed type. Anyway, Python
69 doesn't allow strings to be longer than this. */
70 if (size > PY_SSIZE_T_MAX)
71 goto overflow;
72
73 if (size < alloc / 2) {
74 /* Major downsize; resize down to exact size. */
75 alloc = size + 1;
76 }
77 else if (size < alloc) {
78 /* Within allocated size; quick exit */
79 return 0;
80 }
81 else if (size <= alloc * 1.125) {
82 /* Moderate upsize; overallocate similar to list_resize() */
83 alloc = size + (size >> 3) + (size < 9 ? 3 : 6);
84 }
85 else {
86 /* Major upsize; resize up to exact size */
87 alloc = size + 1;
88 }
89
90 if (alloc > ((size_t)-1) / sizeof(char))
91 goto overflow;
92 new_buf = (char *)PyMem_Realloc(self->buf, alloc * sizeof(char));
93 if (new_buf == NULL) {
94 PyErr_NoMemory();
95 return -1;
96 }
97 self->buf_size = alloc;
98 self->buf = new_buf;
99
100 return 0;
101
102 overflow:
103 PyErr_SetString(PyExc_OverflowError,
104 "new buffer size too large");
105 return -1;
106 }
107
108 /* Internal routine for writing a string of bytes to the buffer of a BytesIO
109 object. Returns the number of bytes wrote, or -1 on error. */
110 static Py_ssize_t
111 write_bytes(bytesio *self, const char *bytes, Py_ssize_t len)
112 {
113 assert(self->buf != NULL);
114 assert(self->pos >= 0);
115 assert(len >= 0);
116
117 if ((size_t)self->pos + len > self->buf_size) {
118 if (resize_buffer(self, (size_t)self->pos + len) < 0)
119 return -1;
120 }
121
122 if (self->pos > self->string_size) {
123 /* In case of overseek, pad with null bytes the buffer region between
124 the end of stream and the current position.
125
126 0 lo string_size hi
127 | |<---used--->|<----------available----------->|
128 | | <--to pad-->|<---to write---> |
129 0 buf position
130 */
131 memset(self->buf + self->string_size, '\0',
132 (self->pos - self->string_size) * sizeof(char));
133 }
134
135 /* Copy the data to the internal buffer, overwriting some of the existing
136 data if self->pos < self->string_size. */
137 memcpy(self->buf + self->pos, bytes, len);
138 self->pos += len;
139
140 /* Set the new length of the internal string if it has changed. */
141 if (self->string_size < self->pos) {
142 self->string_size = self->pos;
143 }
144
145 return len;
146 }
147
148 static PyObject *
149 bytesio_get_closed(bytesio *self)
150 {
151 if (self->buf == NULL) {
152 Py_RETURN_TRUE;
153 }
154 else {
155 Py_RETURN_FALSE;
156 }
157 }
158
159 /* Generic getter for the writable, readable and seekable properties */
160 static PyObject *
161 return_true(bytesio *self)
162 {
163 Py_RETURN_TRUE;
164 }
165
166 PyDoc_STRVAR(flush_doc,
167 "flush() -> None. Does nothing.");
168
169 static PyObject *
170 bytesio_flush(bytesio *self)
171 {
172 CHECK_CLOSED(self);
173 Py_RETURN_NONE;
174 }
175
176 PyDoc_STRVAR(getval_doc,
177 "getvalue() -> bytes.\n"
178 "\n"
179 "Retrieve the entire contents of the BytesIO object.");
180
181 static PyObject *
182 bytesio_getvalue(bytesio *self)
183 {
184 CHECK_CLOSED(self);
185 return PyBytes_FromStringAndSize(self->buf, self->string_size);
186 }
187
188 PyDoc_STRVAR(isatty_doc,
189 "isatty() -> False.\n"
190 "\n"
191 "Always returns False since BytesIO objects are not connected\n"
192 "to a tty-like device.");
193
194 static PyObject *
195 bytesio_isatty(bytesio *self)
196 {
197 CHECK_CLOSED(self);
198 Py_RETURN_FALSE;
199 }
200
201 PyDoc_STRVAR(tell_doc,
202 "tell() -> current file position, an integer\n");
203
204 static PyObject *
205 bytesio_tell(bytesio *self)
206 {
207 CHECK_CLOSED(self);
208 return PyLong_FromSsize_t(self->pos);
209 }
210
211 PyDoc_STRVAR(read_doc,
212 "read([size]) -> read at most size bytes, returned as a string.\n"
213 "\n"
214 "If the size argument is negative, read until EOF is reached.\n"
215 "Return an empty string at EOF.");
216
217 static PyObject *
218 bytesio_read(bytesio *self, PyObject *args)
219 {
220 Py_ssize_t size, n;
221 char *output;
222 PyObject *arg = Py_None;
223
224 CHECK_CLOSED(self);
225
226 if (!PyArg_ParseTuple(args, "|O:read", &arg))
227 return NULL;
228
229 if (PyNumber_Check(arg)) {
230 size = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
231 if (size == -1 && PyErr_Occurred())
232 return NULL;
233 }
234 else if (arg == Py_None) {
235 /* Read until EOF is reached, by default. */
236 size = -1;
237 }
238 else {
239 PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",
240 Py_TYPE(arg)->tp_name);
241 return NULL;
242 }
243
244 /* adjust invalid sizes */
245 n = self->string_size - self->pos;
246 if (size < 0 || size > n) {
247 size = n;
248 if (size < 0)
249 size = 0;
250 }
251
252 assert(self->buf != NULL);
253 output = self->buf + self->pos;
254 self->pos += size;
255
256 return PyBytes_FromStringAndSize(output, size);
257 }
258
259
260 PyDoc_STRVAR(read1_doc,
261 "read1(size) -> read at most size bytes, returned as a string.\n"
262 "\n"
263 "If the size argument is negative or omitted, read until EOF is reached.\n"
264 "Return an empty string at EOF.");
265
266 static PyObject *
267 bytesio_read1(bytesio *self, PyObject *n)
268 {
269 PyObject *arg, *res;
270
271 arg = PyTuple_Pack(1, n);
272 if (arg == NULL)
273 return NULL;
274 res = bytesio_read(self, arg);
275 Py_DECREF(arg);
276 return res;
277 }
278
279 PyDoc_STRVAR(readline_doc,
280 "readline([size]) -> next line from the file, as a string.\n"
281 "\n"
282 "Retain newline. A non-negative size argument limits the maximum\n"
283 "number of bytes to return (an incomplete line may be returned then).\n"
284 "Return an empty string at EOF.\n");
285
286 static PyObject *
287 bytesio_readline(bytesio *self, PyObject *args)
288 {
289 Py_ssize_t size, n;
290 char *output;
291 PyObject *arg = Py_None;
292
293 CHECK_CLOSED(self);
294
295 if (!PyArg_ParseTuple(args, "|O:readline", &arg))
296 return NULL;
297
298 if (PyNumber_Check(arg)) {
299 size = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
300 if (size == -1 && PyErr_Occurred())
301 return NULL;
302 }
303 else if (arg == Py_None) {
304 /* No size limit, by default. */
305 size = -1;
306 }
307 else {
308 PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",
309 Py_TYPE(arg)->tp_name);
310 return NULL;
311 }
312
313 n = get_line(self, &output);
314
315 if (size >= 0 && size < n) {
316 size = n - size;
317 n -= size;
318 self->pos -= size;
319 }
320
321 return PyBytes_FromStringAndSize(output, n);
322 }
323
324 PyDoc_STRVAR(readlines_doc,
325 "readlines([size]) -> list of strings, each a line from the file.\n"
326 "\n"
327 "Call readline() repeatedly and return a list of the lines so read.\n"
328 "The optional size argument, if given, is an approximate bound on the\n"
329 "total number of bytes in the lines returned.\n");
330
331 static PyObject *
332 bytesio_readlines(bytesio *self, PyObject *args)
333 {
334 Py_ssize_t maxsize, size, n;
335 PyObject *result, *line;
336 char *output;
337 PyObject *arg = Py_None;
338
339 CHECK_CLOSED(self);
340
341 if (!PyArg_ParseTuple(args, "|O:readlines", &arg))
342 return NULL;
343
344 if (PyNumber_Check(arg)) {
345 maxsize = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
346 if (maxsize == -1 && PyErr_Occurred())
347 return NULL;
348 }
349 else if (arg == Py_None) {
350 /* No size limit, by default. */
351 maxsize = -1;
352 }
353 else {
354 PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",
355 Py_TYPE(arg)->tp_name);
356 return NULL;
357 }
358
359 size = 0;
360 result = PyList_New(0);
361 if (!result)
362 return NULL;
363
364 while ((n = get_line(self, &output)) != 0) {
365 line = PyBytes_FromStringAndSize(output, n);
366 if (!line)
367 goto on_error;
368 if (PyList_Append(result, line) == -1) {
369 Py_DECREF(line);
370 goto on_error;
371 }
372 Py_DECREF(line);
373 size += n;
374 if (maxsize > 0 && size >= maxsize)
375 break;
376 }
377 return result;
378
379 on_error:
380 Py_DECREF(result);
381 return NULL;
382 }
383
384 PyDoc_STRVAR(readinto_doc,
385 "readinto(bytearray) -> int. Read up to len(b) bytes into b.\n"
386 "\n"
387 "Returns number of bytes read (0 for EOF), or None if the object\n"
388 "is set not to block as has no data to read.");
389
390 static PyObject *
391 bytesio_readinto(bytesio *self, PyObject *args)
392 {
393 Py_buffer buf;
394 Py_ssize_t len, n;
395
396 CHECK_CLOSED(self);
397
398 if (!PyArg_ParseTuple(args, "w*", &buf))
399 return NULL;
400
401 len = buf.len;
402 /* adjust invalid sizes */
403 n = self->string_size - self->pos;
404 if (len > n) {
405 len = n;
406 if (len < 0)
407 len = 0;
408 }
409
410 memcpy(buf.buf, self->buf + self->pos, len);
411 assert(self->pos + len < PY_SSIZE_T_MAX);
412 assert(len >= 0);
413 self->pos += len;
414
415 PyBuffer_Release(&buf);
416 return PyLong_FromSsize_t(len);
417 }
418
419 PyDoc_STRVAR(truncate_doc,
420 "truncate([size]) -> int. Truncate the file to at most size bytes.\n"
421 "\n"
422 "Size defaults to the current file position, as returned by tell().\n"
423 "The current file position is unchanged. Returns the new size.\n");
424
425 static PyObject *
426 bytesio_truncate(bytesio *self, PyObject *args)
427 {
428 Py_ssize_t size;
429 PyObject *arg = Py_None;
430
431 CHECK_CLOSED(self);
432
433 if (!PyArg_ParseTuple(args, "|O:truncate", &arg))
434 return NULL;
435
436 if (PyNumber_Check(arg)) {
437 size = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
438 if (size == -1 && PyErr_Occurred())
439 return NULL;
440 }
441 else if (arg == Py_None) {
442 /* Truncate to current position if no argument is passed. */
443 size = self->pos;
444 }
445 else {
446 PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",
447 Py_TYPE(arg)->tp_name);
448 return NULL;
449 }
450
451 if (size < 0) {
452 PyErr_Format(PyExc_ValueError,
453 "negative size value %zd", size);
454 return NULL;
455 }
456
457 if (size < self->string_size) {
458 self->string_size = size;
459 if (resize_buffer(self, size) < 0)
460 return NULL;
461 }
462
463 return PyLong_FromSsize_t(size);
464 }
465
466 static PyObject *
467 bytesio_iternext(bytesio *self)
468 {
469 char *next;
470 Py_ssize_t n;
471
472 CHECK_CLOSED(self);
473
474 n = get_line(self, &next);
475
476 if (!next || n == 0)
477 return NULL;
478
479 return PyBytes_FromStringAndSize(next, n);
480 }
481
482 PyDoc_STRVAR(seek_doc,
483 "seek(pos, whence=0) -> int. Change stream position.\n"
484 "\n"
485 "Seek to byte offset pos relative to position indicated by whence:\n"
486 " 0 Start of stream (the default). pos should be >= 0;\n"
487 " 1 Current position - pos may be negative;\n"
488 " 2 End of stream - pos usually negative.\n"
489 "Returns the new absolute position.");
490
491 static PyObject *
492 bytesio_seek(bytesio *self, PyObject *args)
493 {
494 PyObject *posobj;
495 Py_ssize_t pos;
496 int mode = 0;
497
498 CHECK_CLOSED(self);
499
500 if (!PyArg_ParseTuple(args, "O|i:seek", &posobj, &mode))
501 return NULL;
502
503 pos = PyNumber_AsSsize_t(posobj, PyExc_OverflowError);
504 if (pos == -1 && PyErr_Occurred())
505 return NULL;
506
507 if (pos < 0 && mode == 0) {
508 PyErr_Format(PyExc_ValueError,
509 "negative seek value %zd", pos);
510 return NULL;
511 }
512
513 /* mode 0: offset relative to beginning of the string.
514 mode 1: offset relative to current position.
515 mode 2: offset relative the end of the string. */
516 if (mode == 1) {
517 if (pos > PY_SSIZE_T_MAX - self->pos) {
518 PyErr_SetString(PyExc_OverflowError,
519 "new position too large");
520 return NULL;
521 }
522 pos += self->pos;
523 }
524 else if (mode == 2) {
525 if (pos > PY_SSIZE_T_MAX - self->string_size) {
526 PyErr_SetString(PyExc_OverflowError,
527 "new position too large");
528 return NULL;
529 }
530 pos += self->string_size;
531 }
532 else if (mode != 0) {
533 PyErr_Format(PyExc_ValueError,
534 "invalid whence (%i, should be 0, 1 or 2)", mode);
535 return NULL;
536 }
537
538 if (pos < 0)
539 pos = 0;
540 self->pos = pos;
541
542 return PyLong_FromSsize_t(self->pos);
543 }
544
545 PyDoc_STRVAR(write_doc,
546 "write(bytes) -> int. Write bytes to file.\n"
547 "\n"
548 "Return the number of bytes written.");
549
550 static PyObject *
551 bytesio_write(bytesio *self, PyObject *obj)
552 {
553 Py_ssize_t n = 0;
554 Py_buffer buf;
555 PyObject *result = NULL;
556
557 CHECK_CLOSED(self);
558
559 if (PyObject_GetBuffer(obj, &buf, PyBUF_CONTIG_RO) < 0)
560 return NULL;
561
562 if (buf.len != 0)
563 n = write_bytes(self, buf.buf, buf.len);
564 if (n >= 0)
565 result = PyLong_FromSsize_t(n);
566
567 PyBuffer_Release(&buf);
568 return result;
569 }
570
571 PyDoc_STRVAR(writelines_doc,
572 "writelines(sequence_of_strings) -> None. Write strings to the file.\n"
573 "\n"
574 "Note that newlines are not added. The sequence can be any iterable\n"
575 "object producing strings. This is equivalent to calling write() for\n"
576 "each string.");
577
578 static PyObject *
579 bytesio_writelines(bytesio *self, PyObject *v)
580 {
581 PyObject *it, *item;
582 PyObject *ret;
583
584 CHECK_CLOSED(self);
585
586 it = PyObject_GetIter(v);
587 if (it == NULL)
588 return NULL;
589
590 while ((item = PyIter_Next(it)) != NULL) {
591 ret = bytesio_write(self, item);
592 Py_DECREF(item);
593 if (ret == NULL) {
594 Py_DECREF(it);
595 return NULL;
596 }
597 Py_DECREF(ret);
598 }
599 Py_DECREF(it);
600
601 /* See if PyIter_Next failed */
602 if (PyErr_Occurred())
603 return NULL;
604
605 Py_RETURN_NONE;
606 }
607
608 PyDoc_STRVAR(close_doc,
609 "close() -> None. Disable all I/O operations.");
610
611 static PyObject *
612 bytesio_close(bytesio *self)
613 {
614 if (self->buf != NULL) {
615 PyMem_Free(self->buf);
616 self->buf = NULL;
617 }
618 Py_RETURN_NONE;
619 }
620
621 /* Pickling support.
622
623 Note that only pickle protocol 2 and onward are supported since we use
624 extended __reduce__ API of PEP 307 to make BytesIO instances picklable.
625
626 Providing support for protocol < 2 would require the __reduce_ex__ method
627 which is notably long-winded when defined properly.
628
629 For BytesIO, the implementation would similar to one coded for
630 object.__reduce_ex__, but slightly less general. To be more specific, we
631 could call bytesio_getstate directly and avoid checking for the presence of
632 a fallback __reduce__ method. However, we would still need a __newobj__
633 function to use the efficient instance representation of PEP 307.
634 */
635
636 static PyObject *
637 bytesio_getstate(bytesio *self)
638 {
639 PyObject *initvalue = bytesio_getvalue(self);
640 PyObject *dict;
641 PyObject *state;
642
643 if (initvalue == NULL)
644 return NULL;
645 if (self->dict == NULL) {
646 Py_INCREF(Py_None);
647 dict = Py_None;
648 }
649 else {
650 dict = PyDict_Copy(self->dict);
651 if (dict == NULL)
652 return NULL;
653 }
654
655 state = Py_BuildValue("(OnN)", initvalue, self->pos, dict);
656 Py_DECREF(initvalue);
657 return state;
658 }
659
660 static PyObject *
661 bytesio_setstate(bytesio *self, PyObject *state)
662 {
663 PyObject *result;
664 PyObject *position_obj;
665 PyObject *dict;
666 Py_ssize_t pos;
667
668 assert(state != NULL);
669
670 /* We allow the state tuple to be longer than 3, because we may need
671 someday to extend the object's state without breaking
672 backward-compatibility. */
673 if (!PyTuple_Check(state) || Py_SIZE(state) < 3) {
674 PyErr_Format(PyExc_TypeError,
675 "%.200s.__setstate__ argument should be 3-tuple, got %.200s",
676 Py_TYPE(self)->tp_name, Py_TYPE(state)->tp_name);
677 return NULL;
678 }
679 /* Reset the object to its default state. This is only needed to handle
680 the case of repeated calls to __setstate__. */
681 self->string_size = 0;
682 self->pos = 0;
683
684 /* Set the value of the internal buffer. If state[0] does not support the
685 buffer protocol, bytesio_write will raise the appropriate TypeError. */
686 result = bytesio_write(self, PyTuple_GET_ITEM(state, 0));
687 if (result == NULL)
688 return NULL;
689 Py_DECREF(result);
690
691 /* Set carefully the position value. Alternatively, we could use the seek
692 method instead of modifying self->pos directly to better protect the
693 object internal state against errneous (or malicious) inputs. */
694 position_obj = PyTuple_GET_ITEM(state, 1);
695 if (!PyIndex_Check(position_obj)) {
696 PyErr_Format(PyExc_TypeError,
697 "second item of state must be an integer, not %.200s",
698 Py_TYPE(position_obj)->tp_name);
699 return NULL;
700 }
701 pos = PyNumber_AsSsize_t(position_obj, PyExc_OverflowError);
702 if (pos == -1 && PyErr_Occurred())
703 return NULL;
704 if (pos < 0) {
705 PyErr_SetString(PyExc_ValueError,
706 "position value cannot be negative");
707 return NULL;
708 }
709 self->pos = pos;
710
711 /* Set the dictionary of the instance variables. */
712 dict = PyTuple_GET_ITEM(state, 2);
713 if (dict != Py_None) {
714 if (!PyDict_Check(dict)) {
715 PyErr_Format(PyExc_TypeError,
716 "third item of state should be a dict, got a %.200s",
717 Py_TYPE(dict)->tp_name);
718 return NULL;
719 }
720 if (self->dict) {
721 /* Alternatively, we could replace the internal dictionary
722 completely. However, it seems more practical to just update it. */
723 if (PyDict_Update(self->dict, dict) < 0)
724 return NULL;
725 }
726 else {
727 Py_INCREF(dict);
728 self->dict = dict;
729 }
730 }
731
732 Py_RETURN_NONE;
733 }
734
735 static void
736 bytesio_dealloc(bytesio *self)
737 {
738 _PyObject_GC_UNTRACK(self);
739 if (self->buf != NULL) {
740 PyMem_Free(self->buf);
741 self->buf = NULL;
742 }
743 Py_CLEAR(self->dict);
744 if (self->weakreflist != NULL)
745 PyObject_ClearWeakRefs((PyObject *) self);
746 Py_TYPE(self)->tp_free(self);
747 }
748
749 static PyObject *
750 bytesio_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
751 {
752 bytesio *self;
753
754 assert(type != NULL && type->tp_alloc != NULL);
755 self = (bytesio *)type->tp_alloc(type, 0);
756 if (self == NULL)
757 return NULL;
758
759 /* tp_alloc initializes all the fields to zero. So we don't have to
760 initialize them here. */
761
762 self->buf = (char *)PyMem_Malloc(0);
763 if (self->buf == NULL) {
764 Py_DECREF(self);
765 return PyErr_NoMemory();
766 }
767
768 return (PyObject *)self;
769 }
770
771 static int
772 bytesio_init(bytesio *self, PyObject *args, PyObject *kwds)
773 {
774 char *kwlist[] = {"initial_bytes", NULL};
775 PyObject *initvalue = NULL;
776
777 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:BytesIO", kwlist,
778 &initvalue))
779 return -1;
780
781 /* In case, __init__ is called multiple times. */
782 self->string_size = 0;
783 self->pos = 0;
784
785 if (initvalue && initvalue != Py_None) {
786 PyObject *res;
787 res = bytesio_write(self, initvalue);
788 if (res == NULL)
789 return -1;
790 Py_DECREF(res);
791 self->pos = 0;
792 }
793
794 return 0;
795 }
796
797 static int
798 bytesio_traverse(bytesio *self, visitproc visit, void *arg)
799 {
800 Py_VISIT(self->dict);
801 return 0;
802 }
803
804 static int
805 bytesio_clear(bytesio *self)
806 {
807 Py_CLEAR(self->dict);
808 return 0;
809 }
810
811
812 static PyGetSetDef bytesio_getsetlist[] = {
813 {"closed", (getter)bytesio_get_closed, NULL,
814 "True if the file is closed."},
815 {NULL}, /* sentinel */
816 };
817
818 static struct PyMethodDef bytesio_methods[] = {
819 {"readable", (PyCFunction)return_true, METH_NOARGS, NULL},
820 {"seekable", (PyCFunction)return_true, METH_NOARGS, NULL},
821 {"writable", (PyCFunction)return_true, METH_NOARGS, NULL},
822 {"close", (PyCFunction)bytesio_close, METH_NOARGS, close_doc},
823 {"flush", (PyCFunction)bytesio_flush, METH_NOARGS, flush_doc},
824 {"isatty", (PyCFunction)bytesio_isatty, METH_NOARGS, isatty_doc},
825 {"tell", (PyCFunction)bytesio_tell, METH_NOARGS, tell_doc},
826 {"write", (PyCFunction)bytesio_write, METH_O, write_doc},
827 {"writelines", (PyCFunction)bytesio_writelines, METH_O, writelines_doc},
828 {"read1", (PyCFunction)bytesio_read1, METH_O, read1_doc},
829 {"readinto", (PyCFunction)bytesio_readinto, METH_VARARGS, readinto_doc},
830 {"readline", (PyCFunction)bytesio_readline, METH_VARARGS, readline_doc},
831 {"readlines", (PyCFunction)bytesio_readlines, METH_VARARGS, readlines_doc},
832 {"read", (PyCFunction)bytesio_read, METH_VARARGS, read_doc},
833 {"getvalue", (PyCFunction)bytesio_getvalue, METH_NOARGS, getval_doc},
834 {"seek", (PyCFunction)bytesio_seek, METH_VARARGS, seek_doc},
835 {"truncate", (PyCFunction)bytesio_truncate, METH_VARARGS, truncate_doc},
836 {"__getstate__", (PyCFunction)bytesio_getstate, METH_NOARGS, NULL},
837 {"__setstate__", (PyCFunction)bytesio_setstate, METH_O, NULL},
838 {NULL, NULL} /* sentinel */
839 };
840
841 PyDoc_STRVAR(bytesio_doc,
842 "BytesIO([buffer]) -> object\n"
843 "\n"
844 "Create a buffered I/O implementation using an in-memory bytes\n"
845 "buffer, ready for reading and writing.");
846
847 PyTypeObject PyBytesIO_Type = {
848 PyVarObject_HEAD_INIT(NULL, 0)
849 "_io.BytesIO", /*tp_name*/
850 sizeof(bytesio), /*tp_basicsize*/
851 0, /*tp_itemsize*/
852 (destructor)bytesio_dealloc, /*tp_dealloc*/
853 0, /*tp_print*/
854 0, /*tp_getattr*/
855 0, /*tp_setattr*/
856 0, /*tp_reserved*/
857 0, /*tp_repr*/
858 0, /*tp_as_number*/
859 0, /*tp_as_sequence*/
860 0, /*tp_as_mapping*/
861 0, /*tp_hash*/
862 0, /*tp_call*/
863 0, /*tp_str*/
864 0, /*tp_getattro*/
865 0, /*tp_setattro*/
866 0, /*tp_as_buffer*/
867 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
868 Py_TPFLAGS_HAVE_GC, /*tp_flags*/
869 bytesio_doc, /*tp_doc*/
870 (traverseproc)bytesio_traverse, /*tp_traverse*/
871 (inquiry)bytesio_clear, /*tp_clear*/
872 0, /*tp_richcompare*/
873 offsetof(bytesio, weakreflist), /*tp_weaklistoffset*/
874 PyObject_SelfIter, /*tp_iter*/
875 (iternextfunc)bytesio_iternext, /*tp_iternext*/
876 bytesio_methods, /*tp_methods*/
877 0, /*tp_members*/
878 bytesio_getsetlist, /*tp_getset*/
879 0, /*tp_base*/
880 0, /*tp_dict*/
881 0, /*tp_descr_get*/
882 0, /*tp_descr_set*/
883 offsetof(bytesio, dict), /*tp_dictoffset*/
884 (initproc)bytesio_init, /*tp_init*/
885 0, /*tp_alloc*/
886 bytesio_new, /*tp_new*/
887 };