#include "Python.h"

#ifdef STDC_HEADERS

#include <stddef.h>

#else /* !STDC_HEADERS */

#ifndef DONT_HAVE_SYS_TYPES_H

#include <sys/types.h> /* For size_t */

#endif /* DONT_HAVE_SYS_TYPES_H */

#endif /* !STDC_HEADERS */

static int

roundupsize(int n)

{

unsigned int nbits = 0;

unsigned int n2 = (unsigned int)n >> 5;

/* Round up:

do {

n2 >>= 3;

nbits += 3;

} while (n2);

return ((n >> nbits) + 1) << nbits;

}

#define NRESIZE(var, type, nitems) \

do { \

size_t _new_size = roundupsize(nitems); \

if (_new_size <= ((~(size_t)0) / sizeof(type))) \

PyMem_RESIZE(var, type, _new_size); \

else \

var = NULL; \

} while (0)

struct arrayobject; /* Forward */

struct arraydescr {

};

typedef struct arrayobject {

} arrayobject;

static PyTypeObject Arraytype;

#define array_Check(op) PyObject_TypeCheck(op, &Arraytype)

#define array_CheckExact(op) ((op)->ob_type == &Arraytype)

static PyObject *

c_getitem(arrayobject *ap, int i)

{

return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1);

}

static int

c_setitem(arrayobject *ap, int i, PyObject *v)

{

char x;

if (!PyArg_Parse(v, "c;array item must be char", &x))

return -1;

if (i >= 0)

((char *)ap->ob_item)[i] = x;

return 0;

}

static PyObject *

b_getitem(arrayobject *ap, int i)

{

long x = ((char *)ap->ob_item)[i];

if (x >= 128)

x -= 256;

return PyInt_FromLong(x);

}

static int

b_setitem(arrayobject *ap, int i, PyObject *v)

{

short x;

/* PyArg_Parse's 'b' formatter is for an unsigned char, therefore

if (!PyArg_Parse(v, "h;array item must be integer", &x))

return -1;

else if (x < -128) {

PyErr_SetString(PyExc_OverflowError,

"signed char is less than minimum");

return -1;

}

else if (x > 127) {

PyErr_SetString(PyExc_OverflowError,

"signed char is greater than maximum");

return -1;

}

if (i >= 0)

((char *)ap->ob_item)[i] = (char)x;

return 0;

}

static PyObject *

BB_getitem(arrayobject *ap, int i)

{

long x = ((unsigned char *)ap->ob_item)[i];

return PyInt_FromLong(x);

}

static int

BB_setitem(arrayobject *ap, int i, PyObject *v)

{

unsigned char x;

/* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */

if (!PyArg_Parse(v, "b;array item must be integer", &x))

return -1;

if (i >= 0)

((char *)ap->ob_item)[i] = x;

return 0;

}

#ifdef Py_USING_UNICODE

static PyObject *

u_getitem(arrayobject *ap, int i)

{

return PyUnicode_FromUnicode(&((Py_UNICODE *) ap->ob_item)[i], 1);

}

static int

u_setitem(arrayobject *ap, int i, PyObject *v)

{

Py_UNICODE *p;

int len;

if (!PyArg_Parse(v, "u#;array item must be unicode character", &p, &len))

return -1;

if (len != 1) {

PyErr_SetString(PyExc_TypeError, "array item must be unicode character");

return -1;

}

if (i >= 0)

((Py_UNICODE *)ap->ob_item)[i] = p[0];

return 0;

}

static PyObject *

h_getitem(arrayobject *ap, int i)

{

return PyInt_FromLong((long) ((short *)ap->ob_item)[i]);

}

static int

h_setitem(arrayobject *ap, int i, PyObject *v)

{

short x;

/* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */

if (!PyArg_Parse(v, "h;array item must be integer", &x))

return -1;

if (i >= 0)

((short *)ap->ob_item)[i] = x;

return 0;

}

static PyObject *

HH_getitem(arrayobject *ap, int i)

{

return PyInt_FromLong((long) ((unsigned short *)ap->ob_item)[i]);

}

static int

HH_setitem(arrayobject *ap, int i, PyObject *v)

{

int x;

/* PyArg_Parse's 'h' formatter is for a signed short, therefore

if (!PyArg_Parse(v, "i;array item must be integer", &x))

return -1;

else if (x < 0) {

PyErr_SetString(PyExc_OverflowError,

"unsigned short is less than minimum");

return -1;

}

else if (x > USHRT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"unsigned short is greater than maximum");

return -1;

}

if (i >= 0)

((short *)ap->ob_item)[i] = (short)x;

return 0;

}

static PyObject *

i_getitem(arrayobject *ap, int i)

{

return PyInt_FromLong((long) ((int *)ap->ob_item)[i]);

}

static int

i_setitem(arrayobject *ap, int i, PyObject *v)

{

int x;

/* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */

if (!PyArg_Parse(v, "i;array item must be integer", &x))

return -1;

if (i >= 0)

((int *)ap->ob_item)[i] = x;

return 0;

}

static PyObject *

II_getitem(arrayobject *ap, int i)

{

return PyLong_FromUnsignedLong(

(unsigned long) ((unsigned int *)ap->ob_item)[i]);

}

static int

II_setitem(arrayobject *ap, int i, PyObject *v)

{

unsigned long x;

if (PyLong_Check(v)) {

x = PyLong_AsUnsignedLong(v);

if (x == (unsigned long) -1 && PyErr_Occurred())

return -1;

}

else {

long y;

if (!PyArg_Parse(v, "l;array item must be integer", &y))

return -1;

if (y < 0) {

PyErr_SetString(PyExc_OverflowError,

"unsigned int is less than minimum");

return -1;

}

x = (unsigned long)y;

}

if (x > UINT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"unsigned int is greater than maximum");

return -1;

}

if (i >= 0)

((unsigned int *)ap->ob_item)[i] = (unsigned int)x;

return 0;

}

static PyObject *

l_getitem(arrayobject *ap, int i)

{

return PyInt_FromLong(((long *)ap->ob_item)[i]);

}

static int

l_setitem(arrayobject *ap, int i, PyObject *v)

{

long x;

if (!PyArg_Parse(v, "l;array item must be integer", &x))

return -1;

if (i >= 0)

((long *)ap->ob_item)[i] = x;

return 0;

}

static PyObject *

LL_getitem(arrayobject *ap, int i)

{

return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]);

}

static int

LL_setitem(arrayobject *ap, int i, PyObject *v)

{

unsigned long x;

if (PyLong_Check(v)) {

x = PyLong_AsUnsignedLong(v);

if (x == (unsigned long) -1 && PyErr_Occurred())

return -1;

}

else {

long y;

if (!PyArg_Parse(v, "l;array item must be integer", &y))

return -1;

if (y < 0) {

PyErr_SetString(PyExc_OverflowError,

"unsigned long is less than minimum");

return -1;

}

x = (unsigned long)y;

}

if (x > ULONG_MAX) {

PyErr_SetString(PyExc_OverflowError,

"unsigned long is greater than maximum");

return -1;

}

if (i >= 0)

((unsigned long *)ap->ob_item)[i] = x;

return 0;

}

static PyObject *

f_getitem(arrayobject *ap, int i)

{

return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]);

}

static int

f_setitem(arrayobject *ap, int i, PyObject *v)

{

float x;

if (!PyArg_Parse(v, "f;array item must be float", &x))

return -1;

if (i >= 0)

((float *)ap->ob_item)[i] = x;

return 0;

}

static PyObject *

d_getitem(arrayobject *ap, int i)

{

return PyFloat_FromDouble(((double *)ap->ob_item)[i]);

}

static int

d_setitem(arrayobject *ap, int i, PyObject *v)

{

double x;

if (!PyArg_Parse(v, "d;array item must be float", &x))

return -1;

if (i >= 0)

((double *)ap->ob_item)[i] = x;

return 0;

}

static struct arraydescr descriptors[] = {

{'c', sizeof(char), c_getitem, c_setitem},

{'b', sizeof(char), b_getitem, b_setitem},

{'B', sizeof(char), BB_getitem, BB_setitem},

#ifdef Py_USING_UNICODE

{'u', sizeof(Py_UNICODE), u_getitem, u_setitem},

{'h', sizeof(short), h_getitem, h_setitem},

{'H', sizeof(short), HH_getitem, HH_setitem},

{'i', sizeof(int), i_getitem, i_setitem},

{'I', sizeof(int), II_getitem, II_setitem},

{'l', sizeof(long), l_getitem, l_setitem},

{'L', sizeof(long), LL_getitem, LL_setitem},

{'f', sizeof(float), f_getitem, f_setitem},

{'d', sizeof(double), d_getitem, d_setitem},

{'\0', 0, 0, 0} /* Sentinel */

};

static PyObject *

newarrayobject(PyTypeObject *type, int size, struct arraydescr *descr)

{

arrayobject *op;

size_t nbytes;

if (size < 0) {

PyErr_BadInternalCall();

return NULL;

}

nbytes = size * descr->itemsize;

/* Check for overflow */

if (nbytes / descr->itemsize != (size_t)size) {

return PyErr_NoMemory();

}

op = (arrayobject *) type->tp_alloc(type, 0);

if (op == NULL) {

return NULL;

}

op->ob_size = size;

if (size <= 0) {

op->ob_item = NULL;

}

else {

op->ob_item = PyMem_NEW(char, nbytes);

if (op->ob_item == NULL) {

PyObject_Del(op);

return PyErr_NoMemory();

}

}

op->ob_descr = descr;

return (PyObject *) op;

}

static PyObject *

getarrayitem(PyObject *op, int i)

{

register arrayobject *ap;

assert(array_Check(op));

ap = (arrayobject *)op;

assert(i>=0 && i<ap->ob_size);

return (*ap->ob_descr->getitem)(ap, i);

}

static int

ins1(arrayobject *self, int where, PyObject *v)

{

char *items;

if (v == NULL) {

PyErr_BadInternalCall();

return -1;

}

if ((*self->ob_descr->setitem)(self, -1, v) < 0)

return -1;

items = self->ob_item;

NRESIZE(items, char, (self->ob_size+1) * self->ob_descr->itemsize);

if (items == NULL) {

PyErr_NoMemory();

return -1;

}

if (where < 0) {

where += self->ob_size;

if (where < 0)

where = 0;

}

if (where > self->ob_size)

where = self->ob_size;

memmove(items + (where+1)*self->ob_descr->itemsize,

items + where*self->ob_descr->itemsize,

(self->ob_size-where)*self->ob_descr->itemsize);

self->ob_item = items;

self->ob_size++;

return (*self->ob_descr->setitem)(self, where, v);

}

static void

array_dealloc(arrayobject *op)

{

if (op->ob_item != NULL)

PyMem_DEL(op->ob_item);

op->ob_type->tp_free((PyObject *)op);

}

static PyObject *

array_richcompare(PyObject *v, PyObject *w, int op)

{

arrayobject *va, *wa;

PyObject *vi = NULL;

PyObject *wi = NULL;

int i, k;

PyObject *res;

if (!array_Check(v) || !array_Check(w)) {

Py_INCREF(Py_NotImplemented);

return Py_NotImplemented;

}

va = (arrayobject *)v;

wa = (arrayobject *)w;

if (va->ob_size != wa->ob_size && (op == Py_EQ || op == Py_NE)) {

/* Shortcut: if the lengths differ, the arrays differ */

if (op == Py_EQ)

res = Py_False;

else

res = Py_True;

Py_INCREF(res);

return res;

}

/* Search for the first index where items are different */

k = 1;

for (i = 0; i < va->ob_size && i < wa->ob_size; i++) {

vi = getarrayitem(v, i);

wi = getarrayitem(w, i);

if (vi == NULL || wi == NULL) {

Py_XDECREF(vi);

Py_XDECREF(wi);

return NULL;

}

k = PyObject_RichCompareBool(vi, wi, Py_EQ);

if (k == 0)

break; /* Keeping vi and wi alive! */

Py_DECREF(vi);

Py_DECREF(wi);

if (k < 0)

return NULL;

}

if (k) {

/* No more items to compare -- compare sizes */

int vs = va->ob_size;

int ws = wa->ob_size;

int cmp;

switch (op) {

case Py_LT: cmp = vs < ws; break;

case Py_LE: cmp = vs <= ws; break;

case Py_EQ: cmp = vs == ws; break;

case Py_NE: cmp = vs != ws; break;

case Py_GT: cmp = vs > ws; break;

case Py_GE: cmp = vs >= ws; break;

default: return NULL; /* cannot happen */

}

if (cmp)

res = Py_True;

else

res = Py_False;

Py_INCREF(res);

return res;

}

/* We have an item that differs. First, shortcuts for EQ/NE */

if (op == Py_EQ) {

Py_INCREF(Py_False);

res = Py_False;

}

else if (op == Py_NE) {

Py_INCREF(Py_True);

res = Py_True;

}

else {

/* Compare the final item again using the proper operator */

res = PyObject_RichCompare(vi, wi, op);

}

Py_DECREF(vi);

Py_DECREF(wi);

return res;

}

static int

array_length(arrayobject *a)

{

return a->ob_size;

}

static PyObject *

array_item(arrayobject *a, int i)

{

if (i < 0 || i >= a->ob_size) {

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

return NULL;

}

return getarrayitem((PyObject *)a, i);

}

static PyObject *

array_slice(arrayobject *a, int ilow, int ihigh)

{

arrayobject *np;

if (ilow < 0)

ilow = 0;

else if (ilow > a->ob_size)

ilow = a->ob_size;

if (ihigh < 0)

ihigh = 0;

if (ihigh < ilow)

ihigh = ilow;

else if (ihigh > a->ob_size)

ihigh = a->ob_size;

np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr);

if (np == NULL)

return NULL;

memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize,

(ihigh-ilow) * a->ob_descr->itemsize);

return (PyObject *)np;

}

static PyObject *

array_concat(arrayobject *a, PyObject *bb)

{

int size;

arrayobject *np;

if (!array_Check(bb)) {

PyErr_Format(PyExc_TypeError,

"can only append array (not \"%.200s\") to array",

bb->ob_type->tp_name);

return NULL;

}

#define b ((arrayobject *)bb)

if (a->ob_descr != b->ob_descr) {

PyErr_BadArgument();

return NULL;

}

if (a->ob_size > INT_MAX - b->ob_size) {

return PyErr_NoMemory();

}

size = a->ob_size + b->ob_size;

np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);

if (np == NULL) {

return NULL;

}

memcpy(np->ob_item, a->ob_item, a->ob_size*a->ob_descr->itemsize);

memcpy(np->ob_item + a->ob_size*a->ob_descr->itemsize,

b->ob_item, b->ob_size*b->ob_descr->itemsize);

return (PyObject *)np;

#undef b

}

static PyObject *

array_repeat(arrayobject *a, int n)

{

int i;

int size;

arrayobject *np;

char *p;

int nbytes;

if (n < 0)

n = 0;

if ((a->ob_size != 0) && (n > INT_MAX / a->ob_size)) {

return PyErr_NoMemory();

}

size = a->ob_size * n;

np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);

if (np == NULL)

return NULL;

p = np->ob_item;

nbytes = a->ob_size * a->ob_descr->itemsize;

for (i = 0; i < n; i++) {

memcpy(p, a->ob_item, nbytes);

p += nbytes;

}

return (PyObject *) np;

}

static int

array_ass_slice(arrayobject *a, int ilow, int ihigh, PyObject *v)

{

char *item;

int n; /* Size of replacement array */

int d; /* Change in size */

#define b ((arrayobject *)v)

if (v == NULL)

n = 0;

else if (array_Check(v)) {

n = b->ob_size;

if (a == b) {

/* Special case "a[i:j] = a" -- copy b first */

int ret;

v = array_slice(b, 0, n);

ret = array_ass_slice(a, ilow, ihigh, v);

Py_DECREF(v);

return ret;

}

if (b->ob_descr != a->ob_descr) {

PyErr_BadArgument();

return -1;

}

}

else {

PyErr_Format(PyExc_TypeError,

"can only assign array (not \"%.200s\") to array slice",

v->ob_type->tp_name);

return -1;

}

if (ilow < 0)

ilow = 0;

else if (ilow > a->ob_size)

ilow = a->ob_size;

if (ihigh < 0)

ihigh = 0;

if (ihigh < ilow)

ihigh = ilow;

else if (ihigh > a->ob_size)

ihigh = a->ob_size;

item = a->ob_item;

d = n - (ihigh-ilow);

if (d < 0) { /* Delete -d items */

memmove(item + (ihigh+d)*a->ob_descr->itemsize,

item + ihigh*a->ob_descr->itemsize,

(a->ob_size-ihigh)*a->ob_descr->itemsize);

a->ob_size += d;

PyMem_RESIZE(item, char, a->ob_size*a->ob_descr->itemsize);

/* Can't fail */

a->ob_item = item;

}

else if (d > 0) { /* Insert d items */

PyMem_RESIZE(item, char,

(a->ob_size + d)*a->ob_descr->itemsize);

if (item == NULL) {

PyErr_NoMemory();

return -1;

}

memmove(item + (ihigh+d)*a->ob_descr->itemsize,

item + ihigh*a->ob_descr->itemsize,

(a->ob_size-ihigh)*a->ob_descr->itemsize);

a->ob_item = item;

a->ob_size += d;

}

if (n > 0)

memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,

n*b->ob_descr->itemsize);

return 0;

#undef b

}

static int

array_ass_item(arrayobject *a, int i, PyObject *v)

{

if (i < 0 || i >= a->ob_size) {

PyErr_SetString(PyExc_IndexError,

"array assignment index out of range");

return -1;

}

if (v == NULL)

return array_ass_slice(a, i, i+1, v);

return (*a->ob_descr->setitem)(a, i, v);

}

static int

setarrayitem(PyObject *a, int i, PyObject *v)

{

assert(array_Check(a));

return array_ass_item((arrayobject *)a, i, v);

}

static int

array_do_extend(arrayobject *self, PyObject *bb)

{

int size;

if (!array_Check(bb)) {

PyErr_Format(PyExc_TypeError,

"can only extend array with array (not \"%.200s\")",

bb->ob_type->tp_name);

return -1;

}

#define b ((arrayobject *)bb)

if (self->ob_descr != b->ob_descr) {

PyErr_SetString(PyExc_TypeError,

"can only extend with array of same kind");

return -1;

}

if ((self->ob_size > INT_MAX - b->ob_size) ||

((self->ob_size + b->ob_size) > INT_MAX / self->ob_descr->itemsize)) {

PyErr_NoMemory();

return -1;

}

size = self->ob_size + b->ob_size;

PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);

if (self->ob_item == NULL) {

PyObject_Del(self);

PyErr_NoMemory();

return -1;

}

memcpy(self->ob_item + self->ob_size*self->ob_descr->itemsize,

b->ob_item, b->ob_size*b->ob_descr->itemsize);

self->ob_size = size;

return 0;

#undef b

}

static PyObject *

array_inplace_concat(arrayobject *self, PyObject *bb)

{

if (array_do_extend(self, bb) == -1)

return NULL;

Py_INCREF(self);

return (PyObject *)self;

}

static PyObject *

array_inplace_repeat(arrayobject *self, int n)

{

char *items, *p;

int size, i;

if (self->ob_size > 0) {

if (n < 0)

n = 0;

items = self->ob_item;

if ((self->ob_descr->itemsize != 0) &&

(self->ob_size > INT_MAX / self->ob_descr->itemsize)) {

return PyErr_NoMemory();

}

size = self->ob_size * self->ob_descr->itemsize;

if (n == 0) {

PyMem_FREE(items);

self->ob_item = NULL;

self->ob_size = 0;

}

else {

if (size > INT_MAX / n) {

return PyErr_NoMemory();

}

PyMem_Resize(items, char, n * size);

if (items == NULL)

return PyErr_NoMemory();

p = items;

for (i = 1; i < n; i++) {

p += size;

memcpy(p, items, size);

}

self->ob_item = items;

self->ob_size *= n;

}

}

Py_INCREF(self);

return (PyObject *)self;

}

static PyObject *

ins(arrayobject *self, int where, PyObject *v)

{

if (ins1(self, where, v) != 0)

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

array_count(arrayobject *self, PyObject *v)

{

int count = 0;

int i;

for (i = 0; i < self->ob_size; i++) {

PyObject *selfi = getarrayitem((PyObject *)self, i);

int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);

Py_DECREF(selfi);

if (cmp > 0)

count++;

else if (cmp < 0)

return NULL;

}

return PyInt_FromLong((long)count);

}

PyDoc_STRVAR(count_doc,

Return number of occurences of x in the array.");

static PyObject *

array_index(arrayobject *self, PyObject *v)

{

int i;

for (i = 0; i < self->ob_size; i++) {

PyObject *selfi = getarrayitem((PyObject *)self, i);

int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);

Py_DECREF(selfi);

if (cmp > 0) {

return PyInt_FromLong((long)i);

}

else if (cmp < 0)

return NULL;

}

PyErr_SetString(PyExc_ValueError, "array.index(x): x not in list");

return NULL;

}

PyDoc_STRVAR(index_doc,

Return index of first occurence of x in the array.");

static int

array_contains(arrayobject *self, PyObject *v)

{

int i, cmp;

for (i = 0, cmp = 0 ; cmp == 0 && i < self->ob_size; i++) {

PyObject *selfi = getarrayitem((PyObject *)self, i);

cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);

Py_DECREF(selfi);

}

return cmp;

}

static PyObject *

array_remove(arrayobject *self, PyObject *v)

{

int i;

for (i = 0; i < self->ob_size; i++) {

PyObject *selfi = getarrayitem((PyObject *)self,i);

int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);

Py_DECREF(selfi);

if (cmp > 0) {

if (array_ass_slice(self, i, i+1,

(PyObject *)NULL) != 0)

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

else if (cmp < 0)

return NULL;

}

PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in list");

return NULL;

}

PyDoc_STRVAR(remove_doc,

Remove the first occurence of x in the array.");

static PyObject *

array_pop(arrayobject *self, PyObject *args)

{

int i = -1;

PyObject *v;

if (!PyArg_ParseTuple(args, "|i:pop", &i))

return NULL;

if (self->ob_size == 0) {

/* Special-case most common failure cause */

PyErr_SetString(PyExc_IndexError, "pop from empty array");

return NULL;

}

if (i < 0)

i += self->ob_size;

if (i < 0 || i >= self->ob_size) {

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

return NULL;

}

v = getarrayitem((PyObject *)self,i);

if (array_ass_slice(self, i, i+1, (PyObject *)NULL) != 0) {

Py_DECREF(v);

return NULL;

}

return v;

}

PyDoc_STRVAR(pop_doc,

Return the i-th element and delete it from the array. i defaults to -1.");

static PyObject *

array_extend(arrayobject *self, PyObject *bb)

{

if (array_do_extend(self, bb) == -1)

return NULL;

Py_INCREF(Py_None);

return Py_None;

}

PyDoc_STRVAR(extend_doc,

Append array items to the end of the array.");

static PyObject *

array_insert(arrayobject *self, PyObject *args)

{

int i;

PyObject *v;