/* PyBytes (bytearray) implementation */

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

#include "bytes_methods.h"

static PyByteArrayObject *nullbytes = NULL;

void

PyByteArray_Fini(void)

{

    Py_CLEAR(nullbytes);

}

int

PyByteArray_Init(void)

{

    nullbytes = PyObject_New(PyByteArrayObject, &PyByteArray_Type);

    if (nullbytes == NULL)

        return 0;

    nullbytes->ob_bytes = NULL;

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

    nullbytes->ob_exports = 0;

    return 1;

}

/* end nullbytes support */

/* Helpers */

static int

_getbytevalue(PyObject* arg, int *value)

{

    long face_value;

    if (PyBytes_CheckExact(arg)) {

        if (Py_SIZE(arg) != 1) {

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

            return 0;

        }

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

        return 1;

    }

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

        face_value = PyLong_AsLong(arg);

    }

    else {

        PyObject *index = PyNumber_Index(arg);

        if (index == NULL) {

            PyErr_Format(PyExc_TypeError,

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

            return 0;

        }

        face_value = PyLong_AsLong(index);

        Py_DECREF(index);

    }

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

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

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

        return 0;

    }

    *value = face_value;

    return 1;

}

static Py_ssize_t

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

{

    if ( index != 0 ) {

        PyErr_SetString(PyExc_SystemError,

                "accessing non-existent bytes segment");

        return -1;

    }

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

    return Py_SIZE(self);

}

static Py_ssize_t

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

{

    if ( index != 0 ) {

        PyErr_SetString(PyExc_SystemError,

                "accessing non-existent bytes segment");

        return -1;

    }

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

    return Py_SIZE(self);

}

static Py_ssize_t

bytes_buffer_getsegcount(PyByteArrayObject *self, Py_ssize_t *lenp)

{

    if ( lenp )

        *lenp = Py_SIZE(self);

    return 1;

}

static Py_ssize_t

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

{

    if ( index != 0 ) {

        PyErr_SetString(PyExc_SystemError,

                "accessing non-existent bytes segment");

        return -1;

    }

    *ptr = self->ob_bytes;

    return Py_SIZE(self);

}

static int

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

{

        int ret;

        void *ptr;

        if (view == NULL) {

                obj->ob_exports++;

                return 0;

        }

        if (obj->ob_bytes == NULL)

                ptr = "";

        else

                ptr = obj->ob_bytes;

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

        if (ret >= 0) {

                obj->ob_exports++;

        }

        return ret;

}

static void

bytes_releasebuffer(PyByteArrayObject *obj, Py_buffer *view)

{

        obj->ob_exports--;

}

static Py_ssize_t

_getbuffer(PyObject *obj, Py_buffer *view)

{

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

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

    {

        PyErr_Format(PyExc_TypeError,

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

                     Py_TYPE(obj)->tp_name);

        return -1;

    }

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

            return -1;

    return view->len;

}

/* Direct API functions */

PyObject *

PyByteArray_FromObject(PyObject *input)

{

    return PyObject_CallFunctionObjArgs((PyObject *)&PyByteArray_Type,

                                        input, NULL);

}

PyObject *

PyByteArray_FromStringAndSize(const char *bytes, Py_ssize_t size)

{

    PyByteArrayObject *new;

    Py_ssize_t alloc;

    if (size < 0) {

        PyErr_SetString(PyExc_SystemError,

            "Negative size passed to PyByteArray_FromStringAndSize");

        return NULL;

    }

    new = PyObject_New(PyByteArrayObject, &PyByteArray_Type);

    if (new == NULL)

        return NULL;

    if (size == 0) {

        new->ob_bytes = NULL;

        alloc = 0;

    }

    else {

        alloc = size + 1;

        new->ob_bytes = PyMem_Malloc(alloc);

        if (new->ob_bytes == NULL) {

            Py_DECREF(new);

            return PyErr_NoMemory();

        }

        if (bytes != NULL)

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

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

    }

    Py_SIZE(new) = size;

    new->ob_alloc = alloc;

    new->ob_exports = 0;

    return (PyObject *)new;

}

Py_ssize_t

PyByteArray_Size(PyObject *self)

{

    assert(self != NULL);

    assert(PyByteArray_Check(self));

    return PyByteArray_GET_SIZE(self);

}

char  *

PyByteArray_AsString(PyObject *self)

{

    assert(self != NULL);

    assert(PyByteArray_Check(self));

    return PyByteArray_AS_STRING(self);

}

int

PyByteArray_Resize(PyObject *self, Py_ssize_t size)

{

    void *sval;

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

    assert(self != NULL);

    assert(PyByteArray_Check(self));

    assert(size >= 0);

    if (size < alloc / 2) {

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

        alloc = size + 1;

    }

    else if (size < alloc) {

        /* Within allocated size; quick exit */

        Py_SIZE(self) = size;

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

        return 0;

    }

    else if (size <= alloc * 1.125) {

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

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

    }

    else {

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

        alloc = size + 1;

    }

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

            /*

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

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

            */

            PyErr_SetString(PyExc_BufferError,

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

            return -1;

    }

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

    if (sval == NULL) {

        PyErr_NoMemory();

        return -1;

    }

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

    Py_SIZE(self) = size;

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

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

    return 0;

}

PyObject *

PyByteArray_Concat(PyObject *a, PyObject *b)

{

    Py_ssize_t size;

    Py_buffer va, vb;

    PyByteArrayObject *result = NULL;

    va.len = -1;

    vb.len = -1;

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

        _getbuffer(b, &vb) < 0) {

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

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

            goto done;

    }

    size = va.len + vb.len;

    if (size < 0) {

            return PyErr_NoMemory();

            goto done;

    }

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

    if (result != NULL) {

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

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

    }

  done:

    if (va.len != -1)

        PyBuffer_Release(&va);

    if (vb.len != -1)

        PyBuffer_Release(&vb);

    return (PyObject *)result;

}

/* Functions stuffed into the type object */

static Py_ssize_t

bytes_length(PyByteArrayObject *self)

{

    return Py_SIZE(self);

}

static PyObject *

bytes_iconcat(PyByteArrayObject *self, PyObject *other)

{

    Py_ssize_t mysize;

    Py_ssize_t size;

    Py_buffer vo;

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

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

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

        return NULL;

    }

    mysize = Py_SIZE(self);

    size = mysize + vo.len;

    if (size < 0) {

        PyBuffer_Release(&vo);

        return PyErr_NoMemory();

    }

    if (size < self->ob_alloc) {

        Py_SIZE(self) = size;

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

    }

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

        PyBuffer_Release(&vo);

        return NULL;

    }

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

    PyBuffer_Release(&vo);

    Py_INCREF(self);

    return (PyObject *)self;

}

static PyObject *

bytes_repeat(PyByteArrayObject *self, Py_ssize_t count)

{

    PyByteArrayObject *result;

    Py_ssize_t mysize;

    Py_ssize_t size;

    if (count < 0)

        count = 0;

    mysize = Py_SIZE(self);

    size = mysize * count;

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

        return PyErr_NoMemory();

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

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

        if (mysize == 1)

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

        else {

            Py_ssize_t i;

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

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

        }

    }

    return (PyObject *)result;

}

static PyObject *

bytes_irepeat(PyByteArrayObject *self, Py_ssize_t count)

{

    Py_ssize_t mysize;

    Py_ssize_t size;

    if (count < 0)

        count = 0;

    mysize = Py_SIZE(self);

    size = mysize * count;

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

        return PyErr_NoMemory();

    if (size < self->ob_alloc) {

        Py_SIZE(self) = size;

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

    }

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

        return NULL;

    if (mysize == 1)

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

    else {

        Py_ssize_t i;

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

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

    }

    Py_INCREF(self);

    return (PyObject *)self;

}

static PyObject *

bytes_getitem(PyByteArrayObject *self, Py_ssize_t i)

{

    if (i < 0)

        i += Py_SIZE(self);

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

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

        return NULL;

    }

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

}

static PyObject *

bytes_subscript(PyByteArrayObject *self, PyObject *index)

{

    if (PyIndex_Check(index)) {

        Py_ssize_t i = PyNumber_AsSsize_t(index, PyExc_IndexError);

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

            return NULL;

        if (i < 0)

            i += PyByteArray_GET_SIZE(self);

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

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

            return NULL;

        }

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

    }

    else if (PySlice_Check(index)) {

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

        if (PySlice_GetIndicesEx((PySliceObject *)index,

                                 PyByteArray_GET_SIZE(self),

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

            return NULL;

        }

        if (slicelength <= 0)

            return PyByteArray_FromStringAndSize("", 0);

        else if (step == 1) {

            return PyByteArray_FromStringAndSize(self->ob_bytes + start,

                                             slicelength);

        }

        else {

            char *source_buf = PyByteArray_AS_STRING(self);

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

            PyObject *result;

            if (result_buf == NULL)

                return PyErr_NoMemory();

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

                 cur += step, i++) {

                     result_buf[i] = source_buf[cur];

            }

            result = PyByteArray_FromStringAndSize(result_buf, slicelength);

            PyMem_Free(result_buf);

            return result;

        }

    }

    else {

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

        return NULL;

    }

}

static int

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

               PyObject *values)

{

    Py_ssize_t avail, needed;

    void *bytes;

    Py_buffer vbytes;

    int res = 0;

    vbytes.len = -1;

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

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

        int err;

        values = PyByteArray_FromObject(values);

        if (values == NULL)

            return -1;

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

        Py_DECREF(values);

        return err;

    }

    if (values == NULL) {

        /* del b[lo:hi] */

        bytes = NULL;

        needed = 0;

    }

    else {

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

                    PyErr_Format(PyExc_TypeError,

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

                                 Py_TYPE(values)->tp_name);

                    return -1;

            }

            needed = vbytes.len;

            bytes = vbytes.buf;

    }

    if (lo < 0)

        lo = 0;

    if (hi < lo)

        hi = lo;

    if (hi > Py_SIZE(self))

        hi = Py_SIZE(self);

    avail = hi - lo;

    if (avail < 0)

        lo = hi = avail = 0;

    if (avail != needed) {

        if (avail > needed) {

            /*

              0   lo               hi               old_size

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

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

              0   lo      new_hi              new_size