1 /* PyBytes (bytearray) implementation */

     2 

     3 #define PY_SSIZE_T_CLEAN

     4 #include "Python.h"

     5 #include "structmember.h"

     6 #include "bytes_methods.h"

     7 

     8 static PyByteArrayObject *nullbytes = NULL;

     9 

    10 void

    11 PyByteArray_Fini(void)

    12 {

    13     Py_CLEAR(nullbytes);

    14 }

    15 

    16 int

    17 PyByteArray_Init(void)

    18 {

    19     nullbytes = PyObject_New(PyByteArrayObject, &PyByteArray_Type);

    20     if (nullbytes == NULL)

    21         return 0;

    22     nullbytes->ob_bytes = NULL;

    23     Py_SIZE(nullbytes) = nullbytes->ob_alloc = 0;

    24     nullbytes->ob_exports = 0;

    25     return 1;

    26 }

    27 

    28 /* end nullbytes support */

    29 

    30 /* Helpers */

    31 

    32 static int

    33 _getbytevalue(PyObject* arg, int *value)

    34 {

    35     long face_value;

    36 

    37     if (PyBytes_CheckExact(arg)) {

    38         if (Py_SIZE(arg) != 1) {

    39             PyErr_SetString(PyExc_ValueError, "string must be of size 1");

    40             return 0;

    41         }

    42         *value = Py_CHARMASK(((PyBytesObject*)arg)->ob_sval[0]);

    43         return 1;

    44     }

    45     else if (PyInt_Check(arg) || PyLong_Check(arg)) {

    46         face_value = PyLong_AsLong(arg);

    47     }

    48     else {

    49         PyObject *index = PyNumber_Index(arg);

    50         if (index == NULL) {

    51             PyErr_Format(PyExc_TypeError,

    52                          "an integer or string of size 1 is required");

    53             return 0;

    54         }

    55         face_value = PyLong_AsLong(index);

    56         Py_DECREF(index);

    57     }

    58 

    59     if (face_value < 0 || face_value >= 256) {

    60         /* this includes the OverflowError in case the long is too large */

    61         PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");

    62         return 0;

    63     }

    64 

    65     *value = face_value;

    66     return 1;

    67 }

    68 

    69 static Py_ssize_t

    70 bytes_buffer_getreadbuf(PyByteArrayObject *self, Py_ssize_t index, const void **ptr)

    71 {

    72     if ( index != 0 ) {

    73         PyErr_SetString(PyExc_SystemError,

    74                 "accessing non-existent bytes segment");

    75         return -1;

    76     }

    77     *ptr = (void *)self->ob_bytes;

    78     return Py_SIZE(self);

    79 }

    80 

    81 static Py_ssize_t

    82 bytes_buffer_getwritebuf(PyByteArrayObject *self, Py_ssize_t index, const void **ptr)

    83 {

    84     if ( index != 0 ) {

    85         PyErr_SetString(PyExc_SystemError,

    86                 "accessing non-existent bytes segment");

    87         return -1;

    88     }

    89     *ptr = (void *)self->ob_bytes;

    90     return Py_SIZE(self);

    91 }

    92 

    93 static Py_ssize_t

    94 bytes_buffer_getsegcount(PyByteArrayObject *self, Py_ssize_t *lenp)

    95 {

    96     if ( lenp )

    97         *lenp = Py_SIZE(self);

    98     return 1;

    99 }

   100 

   101 static Py_ssize_t

   102 bytes_buffer_getcharbuf(PyByteArrayObject *self, Py_ssize_t index, const char **ptr)

   103 {

   104     if ( index != 0 ) {

   105         PyErr_SetString(PyExc_SystemError,

   106                 "accessing non-existent bytes segment");

   107         return -1;

   108     }

   109     *ptr = self->ob_bytes;

   110     return Py_SIZE(self);

   111 }

   112 

   113 static int

   114 bytes_getbuffer(PyByteArrayObject *obj, Py_buffer *view, int flags)

   115 {

   116         int ret;

   117         void *ptr;

   118         if (view == NULL) {

   119                 obj->ob_exports++;

   120                 return 0;

   121         }

   122         if (obj->ob_bytes == NULL)

   123                 ptr = "";

   124         else

   125                 ptr = obj->ob_bytes;

   126         ret = PyBuffer_FillInfo(view, (PyObject*)obj, ptr, Py_SIZE(obj), 0, flags);

   127         if (ret >= 0) {

   128                 obj->ob_exports++;

   129         }

   130         return ret;

   131 }

   132 

   133 static void

   134 bytes_releasebuffer(PyByteArrayObject *obj, Py_buffer *view)

   135 {

   136         obj->ob_exports--;

   137 }

   138 

   139 static Py_ssize_t

   140 _getbuffer(PyObject *obj, Py_buffer *view)

   141 {

   142     PyBufferProcs *buffer = Py_TYPE(obj)->tp_as_buffer;

   143 

   144     if (buffer == NULL || buffer->bf_getbuffer == NULL)

   145     {

   146         PyErr_Format(PyExc_TypeError,

   147                      "Type %.100s doesn't support the buffer API",

   148                      Py_TYPE(obj)->tp_name);

   149         return -1;

   150     }

   151 

   152     if (buffer->bf_getbuffer(obj, view, PyBUF_SIMPLE) < 0)

   153             return -1;

   154     return view->len;

   155 }

   156 

   157 /* Direct API functions */

   158 

   159 PyObject *

   160 PyByteArray_FromObject(PyObject *input)

   161 {

   162     return PyObject_CallFunctionObjArgs((PyObject *)&PyByteArray_Type,

   163                                         input, NULL);

   164 }

   165 

   166 PyObject *

   167 PyByteArray_FromStringAndSize(const char *bytes, Py_ssize_t size)

   168 {

   169     PyByteArrayObject *new;

   170     Py_ssize_t alloc;

   171 

   172     if (size < 0) {

   173         PyErr_SetString(PyExc_SystemError,

   174             "Negative size passed to PyByteArray_FromStringAndSize");

   175         return NULL;

   176     }

   177 

   178     new = PyObject_New(PyByteArrayObject, &PyByteArray_Type);

   179     if (new == NULL)

   180         return NULL;

   181 

   182     if (size == 0) {

   183         new->ob_bytes = NULL;

   184         alloc = 0;

   185     }

   186     else {

   187         alloc = size + 1;

   188         new->ob_bytes = PyMem_Malloc(alloc);

   189         if (new->ob_bytes == NULL) {

   190             Py_DECREF(new);

   191             return PyErr_NoMemory();

   192         }

   193         if (bytes != NULL)

   194             memcpy(new->ob_bytes, bytes, size);

   195         new->ob_bytes[size] = '\0';  /* Trailing null byte */

   196     }

   197     Py_SIZE(new) = size;

   198     new->ob_alloc = alloc;

   199     new->ob_exports = 0;

   200 

   201     return (PyObject *)new;

   202 }

   203 

   204 Py_ssize_t

   205 PyByteArray_Size(PyObject *self)

   206 {

   207     assert(self != NULL);

   208     assert(PyByteArray_Check(self));

   209 

   210     return PyByteArray_GET_SIZE(self);

   211 }

   212 

   213 char  *

   214 PyByteArray_AsString(PyObject *self)

   215 {

   216     assert(self != NULL);

   217     assert(PyByteArray_Check(self));

   218 

   219     return PyByteArray_AS_STRING(self);

   220 }

   221 

   222 int

   223 PyByteArray_Resize(PyObject *self, Py_ssize_t size)

   224 {

   225     void *sval;

   226     Py_ssize_t alloc = ((PyByteArrayObject *)self)->ob_alloc;

   227 

   228     assert(self != NULL);

   229     assert(PyByteArray_Check(self));

   230     assert(size >= 0);

   231 

   232     if (size < alloc / 2) {

   233         /* Major downsize; resize down to exact size */

   234         alloc = size + 1;

   235     }

   236     else if (size < alloc) {

   237         /* Within allocated size; quick exit */

   238         Py_SIZE(self) = size;

   239         ((PyByteArrayObject *)self)->ob_bytes[size] = '\0'; /* Trailing null */

   240         return 0;

   241     }

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

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

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

   245     }

   246     else {

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

   248         alloc = size + 1;

   249     }

   250 

   251     if (((PyByteArrayObject *)self)->ob_exports > 0) {

   252             /*

   253             fprintf(stderr, "%d: %s", ((PyByteArrayObject *)self)->ob_exports,

   254                     ((PyByteArrayObject *)self)->ob_bytes);

   255             */

   256             PyErr_SetString(PyExc_BufferError,

   257                     "Existing exports of data: object cannot be re-sized");

   258             return -1;

   259     }

   260 

   261     sval = PyMem_Realloc(((PyByteArrayObject *)self)->ob_bytes, alloc);

   262     if (sval == NULL) {

   263         PyErr_NoMemory();

   264         return -1;

   265     }

   266 

   267     ((PyByteArrayObject *)self)->ob_bytes = sval;

   268     Py_SIZE(self) = size;

   269     ((PyByteArrayObject *)self)->ob_alloc = alloc;

   270     ((PyByteArrayObject *)self)->ob_bytes[size] = '\0'; /* Trailing null byte */

   271 

   272     return 0;

   273 }

   274 

   275 PyObject *

   276 PyByteArray_Concat(PyObject *a, PyObject *b)

   277 {

   278     Py_ssize_t size;

   279     Py_buffer va, vb;

   280     PyByteArrayObject *result = NULL;

   281 

   282     va.len = -1;

   283     vb.len = -1;

   284     if (_getbuffer(a, &va) < 0  ||

   285         _getbuffer(b, &vb) < 0) {

   286             PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",

   287                          Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);

   288             goto done;

   289     }

   290 

   291     size = va.len + vb.len;

   292     if (size < 0) {

   293             return PyErr_NoMemory();

   294             goto done;

   295     }

   296 

   297     result = (PyByteArrayObject *) PyByteArray_FromStringAndSize(NULL, size);

   298     if (result != NULL) {

   299         memcpy(result->ob_bytes, va.buf, va.len);

   300         memcpy(result->ob_bytes + va.len, vb.buf, vb.len);

   301     }

   302 

   303   done:

   304     if (va.len != -1)

   305         PyBuffer_Release(&va);

   306     if (vb.len != -1)

   307         PyBuffer_Release(&vb);

   308     return (PyObject *)result;

   309 }

   310 

   311 /* Functions stuffed into the type object */

   312 

   313 static Py_ssize_t

   314 bytes_length(PyByteArrayObject *self)

   315 {

   316     return Py_SIZE(self);

   317 }

   318 

   319 static PyObject *

   320 bytes_iconcat(PyByteArrayObject *self, PyObject *other)

   321 {

   322     Py_ssize_t mysize;

   323     Py_ssize_t size;

   324     Py_buffer vo;

   325 

   326     if (_getbuffer(other, &vo) < 0) {

   327         PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",

   328                      Py_TYPE(other)->tp_name, Py_TYPE(self)->tp_name);

   329         return NULL;

   330     }

   331 

   332     mysize = Py_SIZE(self);

   333     size = mysize + vo.len;

   334     if (size < 0) {

   335         PyBuffer_Release(&vo);

   336         return PyErr_NoMemory();

   337     }

   338     if (size < self->ob_alloc) {

   339         Py_SIZE(self) = size;

   340         self->ob_bytes[Py_SIZE(self)] = '\0'; /* Trailing null byte */

   341     }

   342     else if (PyByteArray_Resize((PyObject *)self, size) < 0) {

   343         PyBuffer_Release(&vo);

   344         return NULL;

   345     }

   346     memcpy(self->ob_bytes + mysize, vo.buf, vo.len);

   347     PyBuffer_Release(&vo);

   348     Py_INCREF(self);

   349     return (PyObject *)self;

   350 }

   351 

   352 static PyObject *

   353 bytes_repeat(PyByteArrayObject *self, Py_ssize_t count)

   354 {

   355     PyByteArrayObject *result;

   356     Py_ssize_t mysize;

   357     Py_ssize_t size;

   358 

   359     if (count < 0)

   360         count = 0;

   361     mysize = Py_SIZE(self);

   362     size = mysize * count;

   363     if (count != 0 && size / count != mysize)

   364         return PyErr_NoMemory();

   365     result = (PyByteArrayObject *)PyByteArray_FromStringAndSize(NULL, size);

   366     if (result != NULL && size != 0) {

   367         if (mysize == 1)

   368             memset(result->ob_bytes, self->ob_bytes[0], size);

   369         else {

   370             Py_ssize_t i;

   371             for (i = 0; i < count; i++)

   372                 memcpy(result->ob_bytes + i*mysize, self->ob_bytes, mysize);

   373         }

   374     }

   375     return (PyObject *)result;

   376 }

   377 

   378 static PyObject *

   379 bytes_irepeat(PyByteArrayObject *self, Py_ssize_t count)

   380 {

   381     Py_ssize_t mysize;

   382     Py_ssize_t size;

   383 

   384     if (count < 0)

   385         count = 0;

   386     mysize = Py_SIZE(self);

   387     size = mysize * count;

   388     if (count != 0 && size / count != mysize)

   389         return PyErr_NoMemory();

   390     if (size < self->ob_alloc) {

   391         Py_SIZE(self) = size;

   392         self->ob_bytes[Py_SIZE(self)] = '\0'; /* Trailing null byte */

   393     }

   394     else if (PyByteArray_Resize((PyObject *)self, size) < 0)

   395         return NULL;

   396 

   397     if (mysize == 1)

   398         memset(self->ob_bytes, self->ob_bytes[0], size);

   399     else {

   400         Py_ssize_t i;

   401         for (i = 1; i < count; i++)

   402             memcpy(self->ob_bytes + i*mysize, self->ob_bytes, mysize);

   403     }

   404 

   405     Py_INCREF(self);

   406     return (PyObject *)self;

   407 }

   408 

   409 static PyObject *

   410 bytes_getitem(PyByteArrayObject *self, Py_ssize_t i)

   411 {

   412     if (i < 0)

   413         i += Py_SIZE(self);

   414     if (i < 0 || i >= Py_SIZE(self)) {

   415         PyErr_SetString(PyExc_IndexError, "bytearray index out of range");

   416         return NULL;

   417     }

   418     return PyInt_FromLong((unsigned char)(self->ob_bytes[i]));

   419 }

   420 

   421 static PyObject *

   422 bytes_subscript(PyByteArrayObject *self, PyObject *index)

   423 {

   424     if (PyIndex_Check(index)) {

   425         Py_ssize_t i = PyNumber_AsSsize_t(index, PyExc_IndexError);

   426 

   427         if (i == -1 && PyErr_Occurred())

   428             return NULL;

   429 

   430         if (i < 0)

   431             i += PyByteArray_GET_SIZE(self);

   432 

   433         if (i < 0 || i >= Py_SIZE(self)) {

   434             PyErr_SetString(PyExc_IndexError, "bytearray index out of range");

   435             return NULL;

   436         }

   437         return PyInt_FromLong((unsigned char)(self->ob_bytes[i]));

   438     }

   439     else if (PySlice_Check(index)) {

   440         Py_ssize_t start, stop, step, slicelength, cur, i;

   441         if (PySlice_GetIndicesEx((PySliceObject *)index,

   442                                  PyByteArray_GET_SIZE(self),

   443                                  &start, &stop, &step, &slicelength) < 0) {

   444             return NULL;

   445         }

   446 

   447         if (slicelength <= 0)

   448             return PyByteArray_FromStringAndSize("", 0);

   449         else if (step == 1) {

   450             return PyByteArray_FromStringAndSize(self->ob_bytes + start,

   451                                              slicelength);

   452         }

   453         else {

   454             char *source_buf = PyByteArray_AS_STRING(self);

   455             char *result_buf = (char *)PyMem_Malloc(slicelength);

   456             PyObject *result;

   457 

   458             if (result_buf == NULL)

   459                 return PyErr_NoMemory();

   460 

   461             for (cur = start, i = 0; i < slicelength;

   462                  cur += step, i++) {

   463                      result_buf[i] = source_buf[cur];

   464             }

   465             result = PyByteArray_FromStringAndSize(result_buf, slicelength);

   466             PyMem_Free(result_buf);

   467             return result;

   468         }

   469     }

   470     else {

   471         PyErr_SetString(PyExc_TypeError, "bytearray indices must be integers");

   472         return NULL;

   473     }

   474 }

   475 

   476 static int

   477 bytes_setslice(PyByteArrayObject *self, Py_ssize_t lo, Py_ssize_t hi,

   478                PyObject *values)

   479 {

   480     Py_ssize_t avail, needed;

   481     void *bytes;

   482     Py_buffer vbytes;

   483     int res = 0;

   484 

   485     vbytes.len = -1;

   486     if (values == (PyObject *)self) {

   487         /* Make a copy and call this function recursively */

   488         int err;

   489         values = PyByteArray_FromObject(values);

   490         if (values == NULL)

   491             return -1;

   492         err = bytes_setslice(self, lo, hi, values);

   493         Py_DECREF(values);

   494         return err;

   495     }

   496     if (values == NULL) {

   497         /* del b[lo:hi] */

   498         bytes = NULL;

   499         needed = 0;

   500     }

   501     else {

   502             if (_getbuffer(values, &vbytes) < 0) {

   503                     PyErr_Format(PyExc_TypeError,

   504                                  "can't set bytearray slice from %.100s",

   505                                  Py_TYPE(values)->tp_name);

   506                     return -1;

   507             }

   508             needed = vbytes.len;

   509             bytes = vbytes.buf;

   510     }

   511 

   512     if (lo < 0)

   513         lo = 0;

   514     if (hi < lo)

   515         hi = lo;

   516     if (hi > Py_SIZE(self))

   517         hi = Py_SIZE(self);

   518 

   519     avail = hi - lo;

   520     if (avail < 0)

   521         lo = hi = avail = 0;

   522 

   523     if (avail != needed) {

   524         if (avail > needed) {

   525             /*

   526               0   lo               hi               old_size

   527               |   |<----avail----->|<-----tomove------>|

   528               |   |<-needed->|<-----tomove------>|

   529               0   lo      new_hi              new_size

   530             */

   531             memmove(self->ob_bytes + lo + needed, self->ob_bytes + hi,

   532                     Py_SIZE(self) - hi);

   533         }

   534         /* XXX(nnorwitz): need to verify this can't overflow! */

   535         if (PyByteArray_Resize((PyObject *)self,

   536                            Py_SIZE(self) + needed - avail) < 0) {

   537                 res = -1;

   538                 goto finish;

   539         }

   540         if (avail < needed) {

   541             /*

   542               0   lo        hi               old_size

   543               |   |<-avail->|<-----tomove------>|

   544               |   |<----needed---->|<-----tomove------>|

   545               0   lo            new_hi              new_size

   546              */

   547             memmove(self->ob_bytes + lo + needed, self->ob_bytes + hi,

   548                     Py_SIZE(self) - lo - needed);

   549         }

   550     }

   551 

   552     if (needed > 0)

   553         memcpy(self->ob_bytes + lo, bytes, needed);

   554 

   555 

   556  finish:

   557     if (vbytes.len != -1)

   558             PyBuffer_Release(&vbytes);

   559     return res;

   560 }

   561 

   562 static int

   563 bytes_setitem(PyByteArrayObject *self, Py_ssize_t i, PyObject *value)

   564 {

   565     int ival;

   566 

   567     if (i < 0)

   568         i += Py_SIZE(self);

   569 

   570     if (i < 0 || i >= Py_SIZE(self)) {

   571         PyErr_SetString(PyExc_IndexError, "bytearray index out of range");

   572         return -1;

   573     }

   574 

   575     if (value == NULL)

   576         return bytes_setslice(self, i, i+1, NULL);

   577 

   578     if (!_getbytevalue(value, &ival))

   579         return -1;

   580 

   581     self->ob_bytes[i] = ival;

   582     return 0;

   583 }

   584 

   585 static int

   586 bytes_ass_subscript(PyByteArrayObject *self, PyObject *index, PyObject *values)

   587 {

   588     Py_ssize_t start, stop, step, slicelen, needed;

   589     char *bytes;

   590 

   591     if (PyIndex_Check(index)) {

   592         Py_ssize_t i = PyNumber_AsSsize_t(index, PyExc_IndexError);

   593 

   594         if (i == -1 && PyErr_Occurred())

   595             return -1;

   596 

   597         if (i < 0)

   598             i += PyByteArray_GET_SIZE(self);

   599 

   600         if (i < 0 || i >= Py_SIZE(self)) {

   601             PyErr_SetString(PyExc_IndexError, "bytearray index out of range");

   602             return -1;

   603         }

   604 

   605         if (values == NULL) {

   606             /* Fall through to slice assignment */

   607             start = i;

   608             stop = i + 1;

   609             step = 1;

   610             slicelen = 1;

   611         }

   612         else {

   613             int ival;

   614             if (!_getbytevalue(values, &ival))

   615                 return -1;

   616             self->ob_bytes[i] = (char)ival;

   617             return 0;

   618         }

   619     }

   620     else if (PySlice_Check(index)) {

   621         if (PySlice_GetIndicesEx((PySliceObject *)index,

   622                                  PyByteArray_GET_SIZE(self),

   623                                  &start, &stop, &step, &slicelen) < 0) {

   624             return -1;

   625         }

   626     }

   627     else {

   628         PyErr_SetString(PyExc_TypeError, "bytearray indices must be integer");

   629         return -1;

   630     }

   631 

   632     if (values == NULL) {

   633         bytes = NULL;

   634         needed = 0;

   635     }

   636     else if (values == (PyObject *)self || !PyByteArray_Check(values)) {

   637         /* Make a copy an call this function recursively */

   638         int err;

   639         values = PyByteArray_FromObject(values);

   640         if (values == NULL)

   641             return -1;

   642         err = bytes_ass_subscript(self, index, values);

   643         Py_DECREF(values);

   644         return err;

   645     }

   646     else {

   647         assert(PyByteArray_Check(values));

   648         bytes = ((PyByteArrayObject *)values)->ob_bytes;

   649         needed = Py_SIZE(values);

   650     }

   651     /* Make sure b[5:2] = ... inserts before 5, not before 2. */

   652     if ((step < 0 && start < stop) ||

   653         (step > 0 && start > stop))

   654         stop = start;

   655     if (step == 1) {

   656         if (slicelen != needed) {

   657             if (slicelen > needed) {

   658                 /*

   659                   0   start           stop              old_size

   660                   |   |<---slicelen--->|<-----tomove------>|

   661                   |   |<-needed->|<-----tomove------>|

   662                   0   lo      new_hi              new_size

   663                 */

   664                 memmove(self->ob_bytes + start + needed, self->ob_bytes + stop,

   665                         Py_SIZE(self) - stop);

   666             }

   667             if (PyByteArray_Resize((PyObject *)self,

   668                                Py_SIZE(self) + needed - slicelen) < 0)

   669                 return -1;

   670             if (slicelen < needed) {

   671                 /*

   672                   0   lo        hi               old_size

   673                   |   |<-avail->|<-----tomove------>|

   674                   |   |<----needed---->|<-----tomove------>|

   675                   0   lo            new_hi              new_size

   676                  */

   677                 memmove(self->ob_bytes + start + needed, self->ob_bytes + stop,

   678                         Py_SIZE(self) - start - needed);

   679             }

   680         }

   681 

   682         if (needed > 0)

   683             memcpy(self->ob_bytes + start, bytes, needed);

   684 

   685         return 0;

   686     }

   687     else {

   688         if (needed == 0) {

   689             /* Delete slice */

   690             Py_ssize_t cur, i;

   691 

   692             if (step < 0) {

   693                 stop = start + 1;

   694                 start = stop + step * (slicelen - 1) - 1;

   695                 step = -step;

   696             }

   697             for (cur = start, i = 0;

   698                  i < slicelen; cur += step, i++) {

   699                 Py_ssize_t lim = step - 1;

   700 

   701                 if (cur + step >= PyByteArray_GET_SIZE(self))

   702                     lim = PyByteArray_GET_SIZE(self) - cur - 1;

   703 

   704                 memmove(self->ob_bytes + cur - i,

   705                         self->ob_bytes + cur + 1, lim);

   706             }

   707             /* Move the tail of the bytes, in one chunk */

   708             cur = start + slicelen*step;

   709             if (cur < PyByteArray_GET_SIZE(self)) {

   710                 memmove(self->ob_bytes + cur - slicelen,

   711                         self->ob_bytes + cur,

   712                         PyByteArray_GET_SIZE(self) - cur);

   713             }

   714             if (PyByteArray_Resize((PyObject *)self,

   715                                PyByteArray_GET_SIZE(self) - slicelen) < 0)

   716                 return -1;

   717 

   718             return 0;

   719         }

   720         else {

   721             /* Assign slice */

   722             Py_ssize_t cur, i;

   723 

   724             if (needed != slicelen) {

   725                 PyErr_Format(PyExc_ValueError,

   726                              "attempt to assign bytes of size %zd "

   727                              "to extended slice of size %zd",

   728                              needed, slicelen);

   729                 return -1;

   730             }

   731             for (cur = start, i = 0; i < slicelen; cur += step, i++)

   732                 self->ob_bytes[cur] = bytes[i];

   733             return 0;

   734         }

   735     }

   736 }

   737 

   738 static int

   739 bytes_init(PyByteArrayObject *self, PyObject *args, PyObject *kwds)

   740 {

   741     static char *kwlist[] = {"source", "encoding", "errors", 0};

   742     PyObject *arg = NULL;

   743     const char *encoding = NULL;

   744     const char *errors = NULL;

   745     Py_ssize_t count;

   746     PyObject *it;

   747     PyObject *(*iternext)(PyObject *);

   748 

   749     if (Py_SIZE(self) != 0) {

   750         /* Empty previous contents (yes, do this first of all!) */

   751         if (PyByteArray_Resize((PyObject *)self, 0) < 0)

   752             return -1;

   753     }

   754 

   755     /* Parse arguments */

   756     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oss:bytearray", kwlist,

   757                                      &arg, &encoding, &errors))

   758         return -1;

   759 

   760     /* Make a quick exit if no first argument */

   761     if (arg == NULL) {

   762         if (encoding != NULL || errors != NULL) {

   763             PyErr_SetString(PyExc_TypeError,

   764                             "encoding or errors without sequence argument");

   765             return -1;

   766         }

   767         return 0;

   768     }

   769 

   770     if (PyBytes_Check(arg)) {

   771         PyObject *new, *encoded;

   772         if (encoding != NULL) {

   773             encoded = PyCodec_Encode(arg, encoding, errors);

   774             if (encoded == NULL)

   775                 return -1;

   776             assert(PyBytes_Check(encoded));

   777         }

   778         else {

   779             encoded = arg;

   780             Py_INCREF(arg);

   781         }

   782         new = bytes_iconcat(self, arg);

   783         Py_DECREF(encoded);

   784         if (new == NULL)

   785             return -1;

   786         Py_DECREF(new);

   787         return 0;

   788     }

   789 

   790     if (PyUnicode_Check(arg)) {

   791         /* Encode via the codec registry */

   792         PyObject *encoded, *new;

   793         if (encoding == NULL) {

   794             PyErr_SetString(PyExc_TypeError,

   795                             "unicode argument without an encoding");

   796             return -1;

   797         }

   798         encoded = PyCodec_Encode(arg, encoding, errors);

   799         if (encoded == NULL)

   800             return -1;

   801         assert(PyBytes_Check(encoded));

   802         new = bytes_iconcat(self, encoded);

   803         Py_DECREF(encoded);

   804         if (new == NULL)

   805             return -1;

   806         Py_DECREF(new);

   807         return 0;

   808     }

   809 

   810     /* If it's not unicode, there can't be encoding or errors */

   811     if (encoding != NULL || errors != NULL) {

   812         PyErr_SetString(PyExc_TypeError,

   813                         "encoding or errors without a string argument");

   814         return -1;

   815     }

   816 

   817     /* Is it an int? */

   818     count = PyNumber_AsSsize_t(arg, PyExc_ValueError);

   819     if (count == -1 && PyErr_Occurred())

   820         PyErr_Clear();

   821     else {

   822         if (count < 0) {

   823             PyErr_SetString(PyExc_ValueError, "negative count");

   824             return -1;

   825         }

   826         if (count > 0) {

   827             if (PyByteArray_Resize((PyObject *)self, count))

   828                 return -1;

   829             memset(self->ob_bytes, 0, count);

   830         }

   831         return 0;

   832     }

   833 

   834     /* Use the buffer API */

   835     if (PyObject_CheckBuffer(arg)) {

   836         Py_ssize_t size;

   837         Py_buffer view;

   838         if (PyObject_GetBuffer(arg, &view, PyBUF_FULL_RO) < 0)

   839             return -1;

   840         size = view.len;

   841         if (PyByteArray_Resize((PyObject *)self, size) < 0) goto fail;

   842         if (PyBuffer_ToContiguous(self->ob_bytes, &view, size, 'C') < 0)

   843                 goto fail;

   844         PyBuffer_Release(&view);

   845         return 0;

   846     fail:

   847         PyBuffer_Release(&view);

   848         return -1;

   849     }

   850 

   851     /* XXX Optimize this if the arguments is a list, tuple */

   852 

   853     /* Get the iterator */

   854     it = PyObject_GetIter(arg);

   855     if (it == NULL)

   856         return -1;

   857     iternext = *Py_TYPE(it)->tp_iternext;

   858 

   859     /* Run the iterator to exhaustion */

   860     for (;;) {

   861         PyObject *item;

   862         int rc, value;

   863 

   864         /* Get the next item */

   865         item = iternext(it);

   866         if (item == NULL) {

   867             if (PyErr_Occurred()) {

   868                 if (!PyErr_ExceptionMatches(PyExc_StopIteration))

   869                     goto error;

   870                 PyErr_Clear();

   871             }

   872             break;

   873         }

   874 

   875         /* Interpret it as an int (__index__) */

   876         rc = _getbytevalue(item, &value);

   877         Py_DECREF(item);

   878         if (!rc)

   879             goto error;

   880 

   881         /* Append the byte */

   882         if (Py_SIZE(self) < self->ob_alloc)

   883             Py_SIZE(self)++;

   884         else if (PyByteArray_Resize((PyObject *)self, Py_SIZE(self)+1) < 0)

   885             goto error;

   886         self->ob_bytes[Py_SIZE(self)-1] = value;

   887     }

   888 

   889     /* Clean up and return success */

   890     Py_DECREF(it);

   891     return 0;

   892 

   893  error:

   894     /* Error handling when it != NULL */

   895     Py_DECREF(it);

   896     return -1;

   897 }

   898 

   899 /* Mostly copied from string_repr, but without the

   900    "smart quote" functionality. */

   901 static PyObject *

   902 bytes_repr(PyByteArrayObject *self)

   903 {

   904     static const char *hexdigits = "0123456789abcdef";

   905     const char *quote_prefix = "bytearray(b";

   906     const char *quote_postfix = ")";

   907     Py_ssize_t length = Py_SIZE(self);

   908     /* 14 == strlen(quote_prefix) + 2 + strlen(quote_postfix) */

   909     size_t newsize = 14 + 4 * length;

   910     PyObject *v;

   911     if (newsize > PY_SSIZE_T_MAX || newsize / 4 - 3 != length) {

   912         PyErr_SetString(PyExc_OverflowError,

   913             "bytearray object is too large to make repr");

   914         return NULL;

   915     }

   916     v = PyUnicode_FromUnicode(NULL, newsize);

   917     if (v == NULL) {

   918         return NULL;

   919     }

   920     else {

   921         register Py_ssize_t i;

   922         register Py_UNICODE c;

   923         register Py_UNICODE *p;

   924         int quote;

   925 

   926         /* Figure out which quote to use; single is preferred */

   927         quote = '\'';

   928         {

   929             char *test, *start;

   930             start = PyByteArray_AS_STRING(self);

   931             for (test = start; test < start+length; ++test) {

   932                 if (*test == '"') {

   933                     quote = '\''; /* back to single */

   934                     goto decided;

   935                 }

   936                 else if (*test == '\'')

   937                     quote = '"';

   938             }

   939           decided:

   940             ;

   941         }

   942 

   943         p = PyUnicode_AS_UNICODE(v);

   944         while (*quote_prefix)

   945             *p++ = *quote_prefix++;

   946         *p++ = quote;

   947 

   948         for (i = 0; i < length; i++) {

   949             /* There's at least enough room for a hex escape

   950                and a closing quote. */

   951             assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 5);

   952             c = self->ob_bytes[i];

   953             if (c == '\'' || c == '\\')

   954                 *p++ = '\\', *p++ = c;

   955             else if (c == '\t')

   956                 *p++ = '\\', *p++ = 't';

   957             else if (c == '\n')

   958                 *p++ = '\\', *p++ = 'n';

   959             else if (c == '\r')

   960                 *p++ = '\\', *p++ = 'r';

   961             else if (c == 0)

   962                 *p++ = '\\', *p++ = 'x', *p++ = '0', *p++ = '0';

   963             else if (c < ' ' || c >= 0x7f) {

   964                 *p++ = '\\';

   965                 *p++ = 'x';

   966                 *p++ = hexdigits[(c & 0xf0) >> 4];

   967                 *p++ = hexdigits[c & 0xf];

   968             }

   969             else

   970                 *p++ = c;

   971         }

   972         assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 1);

   973         *p++ = quote;

   974         while (*quote_postfix) {

   975            *p++ = *quote_postfix++;

   976         }

   977         *p = '\0';

   978         if (PyUnicode_Resize(&v, (p - PyUnicode_AS_UNICODE(v)))) {

   979             Py_DECREF(v);

   980             return NULL;

   981         }

   982         return v;

   983     }

   984 }

   985 

   986 static PyObject *

   987 bytes_str(PyObject *op)

   988 {

   989 #if 0

   990     if (Py_BytesWarningFlag) {

   991         if (PyErr_WarnEx(PyExc_BytesWarning,

   992                  "str() on a bytearray instance", 1))

   993             return NULL;

   994     }

   995     return bytes_repr((PyByteArrayObject*)op);

   996 #endif

   997     return PyBytes_FromStringAndSize(((PyByteArrayObject*)op)->ob_bytes, Py_SIZE(op));

   998 }

   999 

  1000 static PyObject *

  1001 bytes_richcompare(PyObject *self, PyObject *other, int op)

  1002 {

  1003     Py_ssize_t self_size, other_size;

  1004     Py_buffer self_bytes, other_bytes;

  1005     PyObject *res;

  1006     Py_ssize_t minsize;

  1007     int cmp;

  1008 

  1009     /* Bytes can be compared to anything that supports the (binary)

  1010        buffer API.  Except that a comparison with Unicode is always an

  1011        error, even if the comparison is for equality. */

  1012     if (PyObject_IsInstance(self, (PyObject*)&PyUnicode_Type) ||

  1013         PyObject_IsInstance(other, (PyObject*)&PyUnicode_Type)) {

  1014         if (Py_BytesWarningFlag && op == Py_EQ) {

  1015             if (PyErr_WarnEx(PyExc_BytesWarning,

  1016                             "Comparsion between bytearray and string", 1))

  1017                 return NULL;

  1018         }

  1019 

  1020         Py_INCREF(Py_NotImplemented);

  1021         return Py_NotImplemented;

  1022     }

  1023 

  1024     self_size = _getbuffer(self, &self_bytes);

  1025     if (self_size < 0) {

  1026         PyErr_Clear();

  1027         Py_INCREF(Py_NotImplemented);

  1028         return Py_NotImplemented;

  1029     }

  1030 

  1031     other_size = _getbuffer(other, &other_bytes);

  1032     if (other_size < 0) {

  1033         PyErr_Clear();

  1034         PyBuffer_Release(&self_bytes);

  1035         Py_INCREF(Py_NotImplemented);

  1036         return Py_NotImplemented;

  1037     }

  1038 

  1039     if (self_size != other_size && (op == Py_EQ || op == Py_NE)) {

  1040         /* Shortcut: if the lengths differ, the objects differ */

  1041         cmp = (op == Py_NE);

  1042     }

  1043     else {

  1044         minsize = self_size;

  1045         if (other_size < minsize)

  1046             minsize = other_size;

  1047 

  1048         cmp = memcmp(self_bytes.buf, other_bytes.buf, minsize);

  1049         /* In ISO C, memcmp() guarantees to use unsigned bytes! */

  1050 

  1051         if (cmp == 0) {

  1052             if (self_size < other_size)

  1053                 cmp = -1;

  1054             else if (self_size > other_size)

  1055                 cmp = 1;

  1056         }

  1057 

  1058         switch (op) {

  1059         case Py_LT: cmp = cmp <  0; break;

  1060         case Py_LE: cmp = cmp <= 0; break;

  1061         case Py_EQ: cmp = cmp == 0; break;

  1062         case Py_NE: cmp = cmp != 0; break;

  1063         case Py_GT: cmp = cmp >  0; break;

  1064         case Py_GE: cmp = cmp >= 0; break;

  1065         }

  1066     }

  1067 

  1068     res = cmp ? Py_True : Py_False;

  1069     PyBuffer_Release(&self_bytes);

  1070     PyBuffer_Release(&other_bytes);

  1071     Py_INCREF(res);

  1072     return res;

  1073 }

  1074 

  1075 static void

  1076 bytes_dealloc(PyByteArrayObject *self)

  1077 {

  1078 	if (self->ob_exports > 0) {

  1079 		PyErr_SetString(PyExc_SystemError,

  1080 			"deallocated bytearray object has exported buffers");

  1081 		PyErr_Print();

  1082 	}

  1083     if (self->ob_bytes != 0) {

  1084         PyMem_Free(self->ob_bytes);

  1085     }

  1086     Py_TYPE(self)->tp_free((PyObject *)self);

  1087 }

  1088 

  1089 

  1090 /* -------------------------------------------------------------------- */

  1091 /* Methods */

  1092 

  1093 #define STRINGLIB_CHAR char

  1094 #define STRINGLIB_CMP memcmp

  1095 #define STRINGLIB_LEN PyByteArray_GET_SIZE

  1096 #define STRINGLIB_STR PyByteArray_AS_STRING

  1097 #define STRINGLIB_NEW PyByteArray_FromStringAndSize

  1098 #define STRINGLIB_EMPTY nullbytes

  1099 #define STRINGLIB_CHECK_EXACT PyByteArray_CheckExact

  1100 #define STRINGLIB_MUTABLE 1

  1101 #define FROM_BYTEARRAY 1

  1102 

  1103 #include "stringlib/fastsearch.h"

  1104 #include "stringlib/count.h"

  1105 #include "stringlib/find.h"

  1106 #include "stringlib/partition.h"

  1107 #include "stringlib/ctype.h"

  1108 #include "stringlib/transmogrify.h"

  1109 

  1110 

  1111 /* The following Py_LOCAL_INLINE and Py_LOCAL functions

  1112 were copied from the old char* style string object. */

  1113 

  1114 Py_LOCAL_INLINE(void)

  1115 _adjust_indices(Py_ssize_t *start, Py_ssize_t *end, Py_ssize_t len)

  1116 {

  1117     if (*end > len)

  1118         *end = len;

  1119     else if (*end < 0)

  1120         *end += len;

  1121     if (*end < 0)

  1122         *end = 0;

  1123     if (*start < 0)

  1124         *start += len;

  1125     if (*start < 0)

  1126         *start = 0;

  1127 }

  1128 

  1129 

  1130 Py_LOCAL_INLINE(Py_ssize_t)

  1131 bytes_find_internal(PyByteArrayObject *self, PyObject *args, int dir)

  1132 {

  1133     PyObject *subobj;

  1134     Py_buffer subbuf;

  1135     Py_ssize_t start=0, end=PY_SSIZE_T_MAX;