Py_END_ALLOW_THREADS

for (i = 0; i < Py_SIZE(op); i++) {

item = op->ob_item[i];

Py_INCREF(item);

if (i > 0) {

Py_BEGIN_ALLOW_THREADS

fprintf(fp, ", ");

Py_END_ALLOW_THREADS

}

if (PyObject_Print(item, fp, 0) != 0) {

Py_DECREF(item);

Py_ReprLeave((PyObject *)op);

return -1;

}

Py_DECREF(item);

}

Py_BEGIN_ALLOW_THREADS

fprintf(fp, "]");

Py_END_ALLOW_THREADS

Py_ReprLeave((PyObject *)op);

return 0;

}

static PyObject *

list_repr(PyListObject *v)

{

Py_ssize_t i;

PyObject *s, *temp;

PyObject *pieces = NULL, *result = NULL;

i = Py_ReprEnter((PyObject*)v);

if (i != 0) {

return i > 0 ? PyString_FromString("[...]") : NULL;

}

if (Py_SIZE(v) == 0) {

result = PyString_FromString("[]");

goto Done;

}

pieces = PyList_New(0);

if (pieces == NULL)

goto Done;

/* Do repr() on each element. Note that this may mutate the list,

for (i = 0; i < Py_SIZE(v); ++i) {

int status;

if (Py_EnterRecursiveCall(" while getting the repr of a list"))

goto Done;

s = PyObject_Repr(v->ob_item[i]);

Py_LeaveRecursiveCall();

if (s == NULL)

goto Done;

status = PyList_Append(pieces, s);

Py_DECREF(s); /* append created a new ref */

if (status < 0)

goto Done;

}

/* Add "[]" decorations to the first and last items. */

assert(PyList_GET_SIZE(pieces) > 0);

s = PyString_FromString("[");

if (s == NULL)

goto Done;

temp = PyList_GET_ITEM(pieces, 0);

PyString_ConcatAndDel(&s, temp);

PyList_SET_ITEM(pieces, 0, s);

if (s == NULL)

goto Done;

s = PyString_FromString("]");

if (s == NULL)

goto Done;

temp = PyList_GET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1);

PyString_ConcatAndDel(&temp, s);

PyList_SET_ITEM(pieces, PyList_GET_SIZE(pieces) - 1, temp);

if (temp == NULL)

goto Done;

/* Paste them all together with ", " between. */

s = PyString_FromString(", ");

if (s == NULL)

goto Done;

result = _PyString_Join(s, pieces);

Py_DECREF(s);

Done:

Py_XDECREF(pieces);

Py_ReprLeave((PyObject *)v);

return result;

}

static Py_ssize_t

list_length(PyListObject *a)

{

return Py_SIZE(a);

}

static int

list_contains(PyListObject *a, PyObject *el)

{

Py_ssize_t i;

int cmp;

for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(a); ++i)

cmp = PyObject_RichCompareBool(el, PyList_GET_ITEM(a, i),

Py_EQ);

return cmp;

}

static PyObject *

list_item(PyListObject *a, Py_ssize_t i)

{

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

if (indexerr == NULL) {

indexerr = PyString_FromString(

"list index out of range");

if (indexerr == NULL)

return NULL;

}

PyErr_SetObject(PyExc_IndexError, indexerr);

return NULL;

}

Py_INCREF(a->ob_item[i]);

return a->ob_item[i];

}

static PyObject *

list_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh)

{

PyListObject *np;

PyObject **src, **dest;

Py_ssize_t i, len;

if (ilow < 0)

ilow = 0;

else if (ilow > Py_SIZE(a))

ilow = Py_SIZE(a);

if (ihigh < ilow)

ihigh = ilow;

else if (ihigh > Py_SIZE(a))

ihigh = Py_SIZE(a);

len = ihigh - ilow;

np = (PyListObject *) PyList_New(len);

if (np == NULL)

return NULL;

src = a->ob_item + ilow;

dest = np->ob_item;

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

PyObject *v = src[i];

Py_INCREF(v);

dest[i] = v;

}

return (PyObject *)np;

}

PyObject *

PyList_GetSlice(PyObject *a, Py_ssize_t ilow, Py_ssize_t ihigh)

{

if (!PyList_Check(a)) {

PyErr_BadInternalCall();

return NULL;

}

return list_slice((PyListObject *)a, ilow, ihigh);

}

static PyObject *

list_concat(PyListObject *a, PyObject *bb)

{

Py_ssize_t size;

Py_ssize_t i;

PyObject **src, **dest;

PyListObject *np;

if (!PyList_Check(bb)) {

PyErr_Format(PyExc_TypeError,

"can only concatenate list (not \"%.200s\") to list",

bb->ob_type->tp_name);

return NULL;

}

#define b ((PyListObject *)bb)

size = Py_SIZE(a) + Py_SIZE(b);

if (size < 0)

return PyErr_NoMemory();

np = (PyListObject *) PyList_New(size);

if (np == NULL) {

return NULL;

}

src = a->ob_item;

dest = np->ob_item;

for (i = 0; i < Py_SIZE(a); i++) {

PyObject *v = src[i];

Py_INCREF(v);

dest[i] = v;

}

src = b->ob_item;

dest = np->ob_item + Py_SIZE(a);

for (i = 0; i < Py_SIZE(b); i++) {

PyObject *v = src[i];

Py_INCREF(v);

dest[i] = v;

}

return (PyObject *)np;

#undef b

}

static PyObject *

list_repeat(PyListObject *a, Py_ssize_t n)

{

Py_ssize_t i, j;

Py_ssize_t size;

PyListObject *np;

PyObject **p, **items;

PyObject *elem;

if (n < 0)

n = 0;

if (n > 0 && Py_SIZE(a) > PY_SSIZE_T_MAX / n)

return PyErr_NoMemory();

size = Py_SIZE(a) * n;

if (size == 0)

return PyList_New(0);

np = (PyListObject *) PyList_New(size);

if (np == NULL)

return NULL;

items = np->ob_item;

if (Py_SIZE(a) == 1) {

elem = a->ob_item[0];

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

items[i] = elem;

Py_INCREF(elem);

}

return (PyObject *) np;

}

p = np->ob_item;

items = a->ob_item;

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

for (j = 0; j < Py_SIZE(a); j++) {

*p = items[j];

Py_INCREF(*p);

p++;

}

}

return (PyObject *) np;

}

static int

list_clear(PyListObject *a)

{

Py_ssize_t i;

PyObject **item = a->ob_item;

if (item != NULL) {

/* Because XDECREF can recursively invoke operations on

i = Py_SIZE(a);

Py_SIZE(a) = 0;

a->ob_item = NULL;

a->allocated = 0;

while (--i >= 0) {

Py_XDECREF(item[i]);

}

PyMem_FREE(item);

}

/* Never fails; the return value can be ignored.

return 0;

}

static int

list_ass_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)

{

/* Because [X]DECREF can recursively invoke list operations on

PyObject *recycle_on_stack[8];

PyObject **recycle = recycle_on_stack; /* will allocate more if needed */

PyObject **item;

PyObject **vitem = NULL;

PyObject *v_as_SF = NULL; /* PySequence_Fast(v) */

Py_ssize_t n; /* # of elements in replacement list */

Py_ssize_t norig; /* # of elements in list getting replaced */

Py_ssize_t d; /* Change in size */

Py_ssize_t k;

size_t s;

int result = -1; /* guilty until proved innocent */

#define b ((PyListObject *)v)

if (v == NULL)

n = 0;

else {

if (a == b) {

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

v = list_slice(b, 0, Py_SIZE(b));

if (v == NULL)

return result;

result = list_ass_slice(a, ilow, ihigh, v);

Py_DECREF(v);

return result;

}

v_as_SF = PySequence_Fast(v, "can only assign an iterable");

if(v_as_SF == NULL)

goto Error;

n = PySequence_Fast_GET_SIZE(v_as_SF);

vitem = PySequence_Fast_ITEMS(v_as_SF);

}

if (ilow < 0)

ilow = 0;

else if (ilow > Py_SIZE(a))

ilow = Py_SIZE(a);

if (ihigh < ilow)