1 #include "Python.h"

     2 

     3 typedef struct {

     4     PyObject_HEAD

     5     char *buf;

     6     Py_ssize_t pos;

     7     Py_ssize_t string_size;

     8     size_t buf_size;

     9 } BytesIOObject;

    10 

    11 #define CHECK_CLOSED(self)                                  \

    12     if ((self)->buf == NULL) {                              \

    13         PyErr_SetString(PyExc_ValueError,                   \

    14                         "I/O operation on closed file.");   \

    15         return NULL;                                        \

    16     }

    17 

    18 /* Internal routine to get a line from the buffer of a BytesIO

    19    object. Returns the length between the current position to the

    20    next newline character. */

    21 static Py_ssize_t

    22 get_line(BytesIOObject *self, char **output)

    23 {

    24     char *n;

    25     const char *str_end;

    26     Py_ssize_t len;

    27 

    28     assert(self->buf != NULL);

    29 

    30     /* Move to the end of the line, up to the end of the string, s. */

    31     str_end = self->buf + self->string_size;

    32     for (n = self->buf + self->pos;

    33          n < str_end && *n != '\n';

    34          n++);

    35 

    36     /* Skip the newline character */

    37     if (n < str_end)

    38         n++;

    39 

    40     /* Get the length from the current position to the end of the line. */

    41     len = n - (self->buf + self->pos);

    42     *output = self->buf + self->pos;

    43 

    44     assert(len >= 0);

    45     assert(self->pos < PY_SSIZE_T_MAX - len);

    46     self->pos += len;

    47 

    48     return len;

    49 }

    50 

    51 /* Internal routine for changing the size of the buffer of BytesIO objects.

    52    The caller should ensure that the 'size' argument is non-negative.  Returns

    53    0 on success, -1 otherwise. */

    54 static int

    55 resize_buffer(BytesIOObject *self, size_t size)

    56 {

    57     /* Here, unsigned types are used to avoid dealing with signed integer

    58        overflow, which is undefined in C. */

    59     size_t alloc = self->buf_size;

    60     char *new_buf = NULL;

    61 

    62     assert(self->buf != NULL);

    63 

    64     /* For simplicity, stay in the range of the signed type. Anyway, Python

    65        doesn't allow strings to be longer than this. */

    66     if (size > PY_SSIZE_T_MAX)

    67         goto overflow;

    68 

    69     if (size < alloc / 2) {

    70         /* Major downsize; resize down to exact size. */

    71         alloc = size + 1;

    72     }

    73     else if (size < alloc) {

    74         /* Within allocated size; quick exit */

    75         return 0;

    76     }

    77     else if (size <= alloc * 1.125) {

    78         /* Moderate upsize; overallocate similar to list_resize() */

    79         alloc = size + (size >> 3) + (size < 9 ? 3 : 6);

    80     }

    81     else {

    82         /* Major upsize; resize up to exact size */

    83         alloc = size + 1;

    84     }

    85 

    86     if (alloc > ((size_t)-1) / sizeof(char))

    87         goto overflow;

    88     new_buf = (char *)PyMem_Realloc(self->buf, alloc * sizeof(char));

    89     if (new_buf == NULL) {

    90         PyErr_NoMemory();

    91         return -1;

    92     }

    93     self->buf_size = alloc;

    94     self->buf = new_buf;

    95 

    96     return 0;

    97 

    98   overflow:

    99     PyErr_SetString(PyExc_OverflowError,

   100                     "new buffer size too large");

   101     return -1;

   102 }

   103 

   104 /* Internal routine for writing a string of bytes to the buffer of a BytesIO

   105    object. Returns the number of bytes wrote, or -1 on error. */

   106 static Py_ssize_t

   107 write_bytes(BytesIOObject *self, const char *bytes, Py_ssize_t len)

   108 {

   109     assert(self->buf != NULL);

   110     assert(self->pos >= 0);

   111     assert(len >= 0);

   112 

   113     if ((size_t)self->pos + len > self->buf_size) {

   114         if (resize_buffer(self, (size_t)self->pos + len) < 0)

   115             return -1;

   116     }

   117 

   118     if (self->pos > self->string_size) {

   119         /* In case of overseek, pad with null bytes the buffer region between

   120            the end of stream and the current position.

   121 

   122           0   lo      string_size                           hi

   123           |   |<---used--->|<----------available----------->|

   124           |   |            <--to pad-->|<---to write--->    |

   125           0   buf                   position

   126         */

   127         memset(self->buf + self->string_size, '\0',

   128                (self->pos - self->string_size) * sizeof(char));

   129     }

   130 

   131     /* Copy the data to the internal buffer, overwriting some of the existing

   132        data if self->pos < self->string_size. */

   133     memcpy(self->buf + self->pos, bytes, len);

   134     self->pos += len;

   135 

   136     /* Set the new length of the internal string if it has changed. */

   137     if (self->string_size < self->pos) {

   138         self->string_size = self->pos;

   139     }

   140 

   141     return len;

   142 }

   143 

   144 static PyObject *

   145 bytesio_get_closed(BytesIOObject *self)

   146 {

   147     if (self->buf == NULL)

   148         Py_RETURN_TRUE;

   149     else

   150         Py_RETURN_FALSE;

   151 }

   152 

   153 /* Generic getter for the writable, readable and seekable properties */

   154 static PyObject *

   155 return_true(BytesIOObject *self)

   156 {

   157     Py_RETURN_TRUE;

   158 }

   159 

   160 PyDoc_STRVAR(flush_doc,

   161 "flush() -> None.  Does nothing.");

   162 

   163 static PyObject *

   164 bytesio_flush(BytesIOObject *self)

   165 {

   166     Py_RETURN_NONE;

   167 }

   168 

   169 PyDoc_STRVAR(getval_doc,

   170 "getvalue() -> bytes.\n"

   171 "\n"

   172 "Retrieve the entire contents of the BytesIO object.");

   173 

   174 static PyObject *

   175 bytesio_getvalue(BytesIOObject *self)

   176 {

   177     CHECK_CLOSED(self);

   178     return PyString_FromStringAndSize(self->buf, self->string_size);

   179 }

   180 

   181 PyDoc_STRVAR(isatty_doc,

   182 "isatty() -> False.\n"

   183 "\n"

   184 "Always returns False since BytesIO objects are not connected\n"

   185 "to a tty-like device.");

   186 

   187 static PyObject *

   188 bytesio_isatty(BytesIOObject *self)

   189 {

   190     CHECK_CLOSED(self);

   191     Py_RETURN_FALSE;

   192 }

   193 

   194 PyDoc_STRVAR(tell_doc,

   195 "tell() -> current file position, an integer\n");

   196 

   197 static PyObject *

   198 bytesio_tell(BytesIOObject *self)

   199 {

   200     CHECK_CLOSED(self);

   201     return PyInt_FromSsize_t(self->pos);

   202 }

   203 

   204 PyDoc_STRVAR(read_doc,

   205 "read([size]) -> read at most size bytes, returned as a string.\n"

   206 "\n"

   207 "If the size argument is negative, read until EOF is reached.\n"

   208 "Return an empty string at EOF.");

   209 

   210 static PyObject *

   211 bytesio_read(BytesIOObject *self, PyObject *args)

   212 {

   213     Py_ssize_t size, n;

   214     char *output;

   215     PyObject *arg = Py_None;

   216 

   217     CHECK_CLOSED(self);

   218 

   219     if (!PyArg_ParseTuple(args, "|O:read", &arg))

   220         return NULL;

   221 

   222     if (PyInt_Check(arg)) {

   223         size = PyInt_AsSsize_t(arg);

   224         if (size == -1 && PyErr_Occurred())

   225             return NULL;

   226     }

   227     else if (arg == Py_None) {

   228         /* Read until EOF is reached, by default. */

   229         size = -1;

   230     }

   231     else {

   232         PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",

   233                      Py_TYPE(arg)->tp_name);

   234         return NULL;

   235     }

   236 

   237     /* adjust invalid sizes */

   238     n = self->string_size - self->pos;

   239     if (size < 0 || size > n) {

   240         size = n;

   241         if (size < 0)

   242             size = 0;

   243     }

   244 

   245     assert(self->buf != NULL);

   246     output = self->buf + self->pos;

   247     self->pos += size;

   248 

   249     return PyString_FromStringAndSize(output, size);

   250 }

   251 

   252 

   253 PyDoc_STRVAR(read1_doc,

   254 "read1(size) -> read at most size bytes, returned as a string.\n"

   255 "\n"

   256 "If the size argument is negative or omitted, read until EOF is reached.\n"

   257 "Return an empty string at EOF.");

   258 

   259 static PyObject *

   260 bytesio_read1(BytesIOObject *self, PyObject *n)

   261 {

   262     PyObject *arg, *res;

   263 

   264     arg = PyTuple_Pack(1, n);

   265     if (arg == NULL)

   266         return NULL;

   267     res  = bytesio_read(self, arg);

   268     Py_DECREF(arg);

   269     return res;

   270 }

   271 

   272 PyDoc_STRVAR(readline_doc,

   273 "readline([size]) -> next line from the file, as a string.\n"

   274 "\n"

   275 "Retain newline.  A non-negative size argument limits the maximum\n"

   276 "number of bytes to return (an incomplete line may be returned then).\n"

   277 "Return an empty string at EOF.\n");

   278 

   279 static PyObject *

   280 bytesio_readline(BytesIOObject *self, PyObject *args)

   281 {

   282     Py_ssize_t size, n;

   283     char *output;

   284     PyObject *arg = Py_None;

   285 

   286     CHECK_CLOSED(self);

   287 

   288     if (!PyArg_ParseTuple(args, "|O:readline", &arg))

   289         return NULL;

   290 

   291     if (PyInt_Check(arg)) {

   292         size = PyInt_AsSsize_t(arg);

   293         if (size == -1 && PyErr_Occurred())

   294             return NULL;

   295     }

   296     else if (arg == Py_None) {

   297         /* No size limit, by default. */

   298         size = -1;

   299     }

   300     else {

   301         PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",

   302                      Py_TYPE(arg)->tp_name);

   303         return NULL;

   304     }

   305 

   306     n = get_line(self, &output);

   307 

   308     if (size >= 0 && size < n) {

   309         size = n - size;

   310         n -= size;

   311         self->pos -= size;

   312     }

   313 

   314     return PyString_FromStringAndSize(output, n);

   315 }

   316 

   317 PyDoc_STRVAR(readlines_doc,

   318 "readlines([size]) -> list of strings, each a line from the file.\n"

   319 "\n"

   320 "Call readline() repeatedly and return a list of the lines so read.\n"

   321 "The optional size argument, if given, is an approximate bound on the\n"

   322 "total number of bytes in the lines returned.\n");

   323 

   324 static PyObject *

   325 bytesio_readlines(BytesIOObject *self, PyObject *args)

   326 {

   327     Py_ssize_t maxsize, size, n;

   328     PyObject *result, *line;

   329     char *output;

   330     PyObject *arg = Py_None;

   331 

   332     CHECK_CLOSED(self);

   333 

   334     if (!PyArg_ParseTuple(args, "|O:readlines", &arg))

   335         return NULL;

   336 

   337     if (PyInt_Check(arg)) {

   338         maxsize = PyInt_AsSsize_t(arg);

   339         if (maxsize == -1 && PyErr_Occurred())

   340             return NULL;

   341     }

   342     else if (arg == Py_None) {

   343         /* No size limit, by default. */

   344         maxsize = -1;

   345     }

   346     else {

   347         PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",

   348                      Py_TYPE(arg)->tp_name);

   349         return NULL;

   350     }

   351 

   352     size = 0;

   353     result = PyList_New(0);

   354     if (!result)

   355         return NULL;

   356 

   357     while ((n = get_line(self, &output)) != 0) {

   358         line = PyString_FromStringAndSize(output, n);

   359         if (!line)

   360             goto on_error;

   361         if (PyList_Append(result, line) == -1) {

   362             Py_DECREF(line);

   363             goto on_error;

   364         }

   365         Py_DECREF(line);

   366         size += n;

   367         if (maxsize > 0 && size >= maxsize)

   368             break;

   369     }

   370     return result;

   371 

   372   on_error:

   373     Py_DECREF(result);

   374     return NULL;

   375 }

   376 

   377 PyDoc_STRVAR(readinto_doc,

   378 "readinto(bytearray) -> int.  Read up to len(b) bytes into b.\n"

   379 "\n"

   380 "Returns number of bytes read (0 for EOF), or None if the object\n"

   381 "is set not to block as has no data to read.");

   382 

   383 static PyObject *

   384 bytesio_readinto(BytesIOObject *self, PyObject *buffer)

   385 {

   386     void *raw_buffer;

   387     Py_ssize_t len;

   388 

   389     CHECK_CLOSED(self);

   390 

   391     if (PyObject_AsWriteBuffer(buffer, &raw_buffer, &len) == -1)

   392         return NULL;

   393 

   394     if (self->pos + len > self->string_size)

   395         len = self->string_size - self->pos;

   396 

   397     memcpy(raw_buffer, self->buf + self->pos, len);

   398     assert(self->pos + len < PY_SSIZE_T_MAX);

   399     assert(len >= 0);

   400     self->pos += len;

   401 

   402     return PyInt_FromSsize_t(len);

   403 }

   404 

   405 PyDoc_STRVAR(truncate_doc,

   406 "truncate([size]) -> int.  Truncate the file to at most size bytes.\n"

   407 "\n"

   408 "Size defaults to the current file position, as returned by tell().\n"

   409 "Returns the new size.  Imply an absolute seek to the position size.");

   410 

   411 static PyObject *

   412 bytesio_truncate(BytesIOObject *self, PyObject *args)

   413 {

   414     Py_ssize_t size;

   415     PyObject *arg = Py_None;

   416 

   417     CHECK_CLOSED(self);

   418 

   419     if (!PyArg_ParseTuple(args, "|O:truncate", &arg))

   420         return NULL;

   421 

   422     if (PyInt_Check(arg)) {

   423         size = PyInt_AsSsize_t(arg);

   424         if (size == -1 && PyErr_Occurred())

   425             return NULL;

   426     }

   427     else if (arg == Py_None) {

   428         /* Truncate to current position if no argument is passed. */

   429         size = self->pos;

   430     }

   431     else {

   432         PyErr_Format(PyExc_TypeError, "integer argument expected, got '%s'",

   433                      Py_TYPE(arg)->tp_name);

   434         return NULL;

   435     }

   436 

   437     if (size < 0) {

   438         PyErr_Format(PyExc_ValueError,

   439                      "negative size value %zd", size);

   440         return NULL;

   441     }

   442 

   443     if (size < self->string_size) {

   444         self->string_size = size;

   445         if (resize_buffer(self, size) < 0)

   446             return NULL;

   447     }

   448     self->pos = size;

   449 

   450     return PyInt_FromSsize_t(size);

   451 }

   452 

   453 static PyObject *

   454 bytesio_iternext(BytesIOObject *self)

   455 {

   456     char *next;

   457     Py_ssize_t n;

   458 

   459     CHECK_CLOSED(self);

   460 

   461     n = get_line(self, &next);

   462 

   463     if (!next || n == 0)

   464         return NULL;

   465 

   466     return PyString_FromStringAndSize(next, n);

   467 }

   468 

   469 PyDoc_STRVAR(seek_doc,

   470 "seek(pos, whence=0) -> int.  Change stream position.\n"

   471 "\n"

   472 "Seek to byte offset pos relative to position indicated by whence:\n"

   473 "     0  Start of stream (the default).  pos should be >= 0;\n"

   474 "     1  Current position - pos may be negative;\n"

   475 "     2  End of stream - pos usually negative.\n"

   476 "Returns the new absolute position.");

   477 

   478 static PyObject *

   479 bytesio_seek(BytesIOObject *self, PyObject *args)

   480 {

   481     PyObject *pos_obj, *mode_obj;

   482     Py_ssize_t pos;

   483     int mode = 0;

   484 

   485     CHECK_CLOSED(self);

   486 

   487     /* Special-case for 2.x to prevent floats from passing through.

   488        This only needed to make a test in test_io succeed. */

   489     if (!PyArg_UnpackTuple(args, "seek", 1, 2, &pos_obj, &mode_obj))

   490         return NULL;

   491     if (PyFloat_Check(pos_obj)) {

   492         PyErr_SetString(PyExc_TypeError,

   493                         "position argument must be an integer");

   494         return NULL;

   495     }

   496 

   497     if (!PyArg_ParseTuple(args, "n|i:seek", &pos, &mode))

   498         return NULL;

   499 

   500     if (pos < 0 && mode == 0) {

   501         PyErr_Format(PyExc_ValueError,

   502                      "negative seek value %zd", pos);

   503         return NULL;

   504     }

   505 

   506     /* mode 0: offset relative to beginning of the string.

   507        mode 1: offset relative to current position.

   508        mode 2: offset relative the end of the string. */

   509     if (mode == 1) {

   510         if (pos > PY_SSIZE_T_MAX - self->pos) {

   511             PyErr_SetString(PyExc_OverflowError,

   512                             "new position too large");

   513             return NULL;

   514         }

   515         pos += self->pos;

   516     }

   517     else if (mode == 2) {

   518         if (pos > PY_SSIZE_T_MAX - self->string_size) {

   519             PyErr_SetString(PyExc_OverflowError,

   520                             "new position too large");

   521             return NULL;

   522         }

   523         pos += self->string_size;

   524     }

   525     else if (mode != 0) {

   526         PyErr_Format(PyExc_ValueError,

   527                      "invalid whence (%i, should be 0, 1 or 2)", mode);

   528         return NULL;

   529     }

   530 

   531     if (pos < 0)

   532         pos = 0;

   533     self->pos = pos;

   534 

   535     return PyInt_FromSsize_t(self->pos);

   536 }

   537 

   538 PyDoc_STRVAR(write_doc,

   539 "write(bytes) -> int.  Write bytes to file.\n"

   540 "\n"

   541 "Return the number of bytes written.");

   542 

   543 static PyObject *

   544 bytesio_write(BytesIOObject *self, PyObject *obj)

   545 {

   546     const char *bytes;

   547     Py_ssize_t size;

   548     Py_ssize_t n = 0;

   549 

   550     CHECK_CLOSED(self);

   551 

   552     /* Special-case in 2.x to prevent unicode objects to pass through. */

   553     if (PyUnicode_Check(obj)) {

   554 	    PyErr_SetString(PyExc_TypeError,

   555                         "expecting a bytes object, got unicode");

   556         return NULL;

   557     }

   558 

   559     if (PyObject_AsReadBuffer(obj, (void *)&bytes, &size) < 0)

   560         return NULL;

   561 

   562     if (size != 0) {

   563         n = write_bytes(self, bytes, size);

   564         if (n < 0)

   565             return NULL;

   566     }

   567 

   568     return PyInt_FromSsize_t(n);

   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(BytesIOObject *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(BytesIOObject *self)

   613 {

   614     if (self->buf != NULL) {

   615         PyMem_Free(self->buf);

   616         self->buf = NULL;

   617     }

   618     Py_RETURN_NONE;

   619 }

   620 

   621 static void

   622 bytesio_dealloc(BytesIOObject *self)

   623 {

   624     if (self->buf != NULL) {

   625         PyMem_Free(self->buf);

   626         self->buf = NULL;

   627     }

   628     Py_TYPE(self)->tp_free(self);

   629 }

   630 

   631 static PyObject *

   632 bytesio_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

   633 {

   634     BytesIOObject *self;

   635 

   636     assert(type != NULL && type->tp_alloc != NULL);

   637     self = (BytesIOObject *)type->tp_alloc(type, 0);

   638     if (self == NULL)

   639         return NULL;

   640 

   641     self->string_size = 0;

   642     self->pos = 0;

   643     self->buf_size = 0;

   644     self->buf = (char *)PyMem_Malloc(0);

   645     if (self->buf == NULL) {

   646         Py_DECREF(self);

   647         return PyErr_NoMemory();

   648     }

   649 

   650     return (PyObject *)self;

   651 }

   652 

   653 static int

   654 bytesio_init(BytesIOObject *self, PyObject *args, PyObject *kwds)

   655 {

   656     PyObject *initvalue = NULL;

   657 

   658     if (!PyArg_ParseTuple(args, "|O:BytesIO", &initvalue))

   659         return -1;

   660 

   661     /* In case, __init__ is called multiple times. */

   662     self->string_size = 0;

   663     self->pos = 0;

   664 

   665     if (initvalue && initvalue != Py_None) {

   666         PyObject *res;

   667         res = bytesio_write(self, initvalue);

   668         if (res == NULL)

   669             return -1;

   670         Py_DECREF(res);

   671         self->pos = 0;

   672     }

   673 

   674     return 0;

   675 }

   676 

   677 static PyGetSetDef bytesio_getsetlist[] = {

   678     {"closed",  (getter)bytesio_get_closed, NULL,

   679      "True if the file is closed."},

   680     {0},            /* sentinel */

   681 };

   682 

   683 static struct PyMethodDef bytesio_methods[] = {

   684     {"readable",   (PyCFunction)return_true,        METH_NOARGS, NULL},

   685     {"seekable",   (PyCFunction)return_true,        METH_NOARGS, NULL},

   686     {"writable",   (PyCFunction)return_true,        METH_NOARGS, NULL},

   687     {"close",      (PyCFunction)bytesio_close,      METH_NOARGS, close_doc},

   688     {"flush",      (PyCFunction)bytesio_flush,      METH_NOARGS, flush_doc},

   689     {"isatty",     (PyCFunction)bytesio_isatty,     METH_NOARGS, isatty_doc},

   690     {"tell",       (PyCFunction)bytesio_tell,       METH_NOARGS, tell_doc},

   691     {"write",      (PyCFunction)bytesio_write,      METH_O, write_doc},

   692     {"writelines", (PyCFunction)bytesio_writelines, METH_O, writelines_doc},

   693     {"read1",      (PyCFunction)bytesio_read1,      METH_O, read1_doc},

   694     {"readinto",   (PyCFunction)bytesio_readinto,   METH_O, readinto_doc},

   695     {"readline",   (PyCFunction)bytesio_readline,   METH_VARARGS, readline_doc},

   696     {"readlines",  (PyCFunction)bytesio_readlines,  METH_VARARGS, readlines_doc},

   697     {"read",       (PyCFunction)bytesio_read,       METH_VARARGS, read_doc},

   698     {"getvalue",   (PyCFunction)bytesio_getvalue,   METH_VARARGS, getval_doc},

   699     {"seek",       (PyCFunction)bytesio_seek,       METH_VARARGS, seek_doc},

   700     {"truncate",   (PyCFunction)bytesio_truncate,   METH_VARARGS, truncate_doc},

   701     {NULL, NULL}        /* sentinel */

   702 };

   703 

   704 PyDoc_STRVAR(bytesio_doc,

   705 "BytesIO([buffer]) -> object\n"

   706 "\n"

   707 "Create a buffered I/O implementation using an in-memory bytes\n"

   708 "buffer, ready for reading and writing.");

   709 

   710 static PyTypeObject BytesIO_Type = {

   711     PyVarObject_HEAD_INIT(NULL, 0)

   712     "_bytesio._BytesIO",                       /*tp_name*/

   713     sizeof(BytesIOObject),                     /*tp_basicsize*/

   714     0,                                         /*tp_itemsize*/

   715     (destructor)bytesio_dealloc,               /*tp_dealloc*/

   716     0,                                         /*tp_print*/

   717     0,                                         /*tp_getattr*/

   718     0,                                         /*tp_setattr*/

   719     0,                                         /*tp_compare*/

   720     0,                                         /*tp_repr*/

   721     0,                                         /*tp_as_number*/

   722     0,                                         /*tp_as_sequence*/

   723     0,                                         /*tp_as_mapping*/

   724     0,                                         /*tp_hash*/

   725     0,                                         /*tp_call*/

   726     0,                                         /*tp_str*/

   727     0,                                         /*tp_getattro*/

   728     0,                                         /*tp_setattro*/

   729     0,                                         /*tp_as_buffer*/

   730     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  /*tp_flags*/

   731     bytesio_doc,                               /*tp_doc*/

   732     0,                                         /*tp_traverse*/

   733     0,                                         /*tp_clear*/

   734     0,                                         /*tp_richcompare*/

   735     0,                                         /*tp_weaklistoffset*/

   736     PyObject_SelfIter,                         /*tp_iter*/

   737     (iternextfunc)bytesio_iternext,            /*tp_iternext*/

   738     bytesio_methods,                           /*tp_methods*/

   739     0,                                         /*tp_members*/

   740     bytesio_getsetlist,                        /*tp_getset*/

   741     0,                                         /*tp_base*/

   742     0,                                         /*tp_dict*/

   743     0,                                         /*tp_descr_get*/

   744     0,                                         /*tp_descr_set*/

   745     0,                                         /*tp_dictoffset*/

   746     (initproc)bytesio_init,                    /*tp_init*/

   747     0,                                         /*tp_alloc*/

   748     bytesio_new,                               /*tp_new*/

   749 };

   750 

   751 PyMODINIT_FUNC

   752 init_bytesio(void)

   753 {

   754     PyObject *m;

   755 

   756     if (PyType_Ready(&BytesIO_Type) < 0)

   757         return;

   758     m = Py_InitModule("_bytesio", NULL);

   759     if (m == NULL)

   760         return;

   761     Py_INCREF(&BytesIO_Type);

   762     PyModule_AddObject(m, "_BytesIO", (PyObject *)&BytesIO_Type);

   763 }