Modules/_io/bytesio.c

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