#include "Python.h"

#include "structmember.h"

#ifdef STDC_HEADERS

#include <stddef.h>

#else

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

#endif

/* collections module implementation of a deque() datatype

Written and maintained by Raymond D. Hettinger <python@rcn.com>

*/

/* The block length may be set to any number over 1. Larger numbers

* reduce the number of calls to the memory allocator, give faster

* indexing and rotation, and reduce the link to data overhead ratio.

* Making the block length a power of two speeds-up the modulo

* and division calculations in deque_item() and deque_ass_item().

*/

#define BLOCKLEN 64

#define CENTER ((BLOCKLEN - 1) / 2)

/* Data for deque objects is stored in a doubly-linked list of fixed

* length blocks. This assures that appends or pops never move any

* other data elements besides the one being appended or popped.

*

* Another advantage is that it completely avoids use of realloc(),

* resulting in more predictable performance.

*

* Textbook implementations of doubly-linked lists store one datum

* per link, but that gives them a 200% memory overhead (a prev and

* next link for each datum) and it costs one malloc() call per data

* element. By using fixed-length blocks, the link to data ratio is

* significantly improved and there are proportionally fewer calls

* to malloc() and free(). The data blocks of consecutive pointers

* also improve cache locality.

*

* The list of blocks is never empty, so d.leftblock and d.rightblock

* are never equal to NULL. The list is not circular.

*

* A deque d's first element is at d.leftblock[leftindex]

* and its last element is at d.rightblock[rightindex].

*

* Unlike Python slice indices, these indices are inclusive on both

* ends. This makes the algorithms for left and right operations

* more symmetrical and it simplifies the design.

*

* The indices, d.leftindex and d.rightindex are always in the range:

* 0 <= index < BLOCKLEN

*

* And their exact relationship is:

* (d.leftindex + d.len - 1) % BLOCKLEN == d.rightindex

*

* Whenever d.leftblock == d.rightblock, then:

* d.leftindex + d.len - 1 == d.rightindex

*

* However, when d.leftblock != d.rightblock, the d.leftindex and

* d.rightindex become indices into distinct blocks and either may

* be larger than the other.

*

* Empty deques have:

* d.len == 0

* d.leftblock == d.rightblock

* d.leftindex == CENTER + 1

* d.rightindex == CENTER

*

* Checking for d.len == 0 is the intended way to see whether d is empty.

*/

typedef struct BLOCK {

struct BLOCK *leftlink;

PyObject *data[BLOCKLEN];

struct BLOCK *rightlink;

} block;

typedef struct {

PyObject_VAR_HEAD

block *leftblock;

block *rightblock;

Py_ssize_t leftindex; /* 0 <= leftindex < BLOCKLEN */

Py_ssize_t rightindex; /* 0 <= rightindex < BLOCKLEN */

size_t state; /* incremented whenever the indices move */

Py_ssize_t maxlen;

PyObject *weakreflist;

} dequeobject;

static PyTypeObject deque_type;

/* For debug builds, add error checking to track the endpoints

* in the chain of links. The goal is to make sure that link

* assignments only take place at endpoints so that links already

* in use do not get overwritten.

*

* CHECK_END should happen before each assignment to a block's link field.

* MARK_END should happen whenever a link field becomes a new endpoint.

* This happens when new blocks are added or whenever an existing

* block is freed leaving another existing block as the new endpoint.

*/

#ifndef NDEBUG

#define MARK_END(link) link = NULL;

#define CHECK_END(link) assert(link == NULL);

#define CHECK_NOT_END(link) assert(link != NULL);

#else

#define MARK_END(link)

#define CHECK_END(link)

#define CHECK_NOT_END(link)

#endif

/* To prevent len from overflowing PY_SSIZE_T_MAX, we refuse to

allocate new blocks if the current len is nearing overflow.

*/

#define MAX_DEQUE_LEN (PY_SSIZE_T_MAX - 3*BLOCKLEN)

/* A simple freelisting scheme is used to minimize calls to the memory

allocator. It accommodates common use cases where new blocks are being

added at about the same rate as old blocks are being freed.

*/

#define MAXFREEBLOCKS 10

static Py_ssize_t numfreeblocks = 0;

static block *freeblocks[MAXFREEBLOCKS];

static block *

newblock(Py_ssize_t len) {

block *b;

if (len >= MAX_DEQUE_LEN) {

PyErr_SetString(PyExc_OverflowError,

"cannot add more blocks to the deque");

return NULL;

}

if (numfreeblocks) {

numfreeblocks--;

return freeblocks[numfreeblocks];

}

b = PyMem_Malloc(sizeof(block));

if (b != NULL) {

return b;

}

PyErr_NoMemory();

return NULL;

}

static void

freeblock(block *b)

{

if (numfreeblocks < MAXFREEBLOCKS) {

freeblocks[numfreeblocks] = b;

numfreeblocks++;

} else {

PyMem_Free(b);

}

}

/* XXX Todo:

If aligned memory allocations become available, make the

deque object 64 byte aligned so that all of the fields

can be retrieved or updated in a single cache line.

*/

static PyObject *

deque_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

dequeobject *deque;

block *b;

/* create dequeobject structure */

deque = (dequeobject *)type->tp_alloc(type, 0);

if (deque == NULL)

return NULL;

b = newblock(0);

if (b == NULL) {

Py_DECREF(deque);

return NULL;

}

MARK_END(b->leftlink);

MARK_END(b->rightlink);

assert(BLOCKLEN >= 2);

Py_SIZE(deque) = 0;

deque->leftblock = b;

deque->rightblock = b;

deque->leftindex = CENTER + 1;

deque->rightindex = CENTER;

deque->state = 0;

deque->maxlen = -1;

deque->weakreflist = NULL;

return (PyObject *)deque;

}

static PyObject *

deque_pop(dequeobject *deque, PyObject *unused)

{

PyObject *item;

block *prevblock;

if (Py_SIZE(deque) == 0) {

PyErr_SetString(PyExc_IndexError, "pop from an empty deque");

return NULL;

}

item = deque->rightblock->data[deque->rightindex];

deque->rightindex--;

Py_SIZE(deque)--;

deque->state++;

if (deque->rightindex == -1) {

if (Py_SIZE(deque)) {

prevblock = deque->rightblock->leftlink;

assert(deque->leftblock != deque->rightblock);

freeblock(deque->rightblock);

CHECK_NOT_END(prevblock);

MARK_END(prevblock->rightlink);

deque->rightblock = prevblock;

deque->rightindex = BLOCKLEN - 1;

} else {

assert(deque->leftblock == deque->rightblock);

assert(deque->leftindex == deque->rightindex+1);

/* re-center instead of freeing a block */

deque->leftindex = CENTER + 1;

deque->rightindex = CENTER;

}

}

return item;

}

PyDoc_STRVAR(pop_doc, "Remove and return the rightmost element.");

static PyObject *

deque_popleft(dequeobject *deque, PyObject *unused)

{

PyObject *item;

block *prevblock;

if (Py_SIZE(deque) == 0) {

PyErr_SetString(PyExc_IndexError, "pop from an empty deque");

return NULL;

}

assert(deque->leftblock != NULL);

item = deque->leftblock->data[deque->leftindex];

deque->leftindex++;

Py_SIZE(deque)--;

deque->state++;

if (deque->leftindex == BLOCKLEN) {

if (Py_SIZE(deque)) {

assert(deque->leftblock != deque->rightblock);

prevblock = deque->leftblock->rightlink;

freeblock(deque->leftblock);

CHECK_NOT_END(prevblock);

MARK_END(prevblock->leftlink);

deque->leftblock = prevblock;

deque->leftindex = 0;

} else {

assert(deque->leftblock == deque->rightblock);

assert(deque->leftindex == deque->rightindex+1);

/* re-center instead of freeing a block */

deque->leftindex = CENTER + 1;

deque->rightindex = CENTER;

}

}

return item;

}

PyDoc_STRVAR(popleft_doc, "Remove and return the leftmost element.");

/* The deque's size limit is d.maxlen. The limit can be zero or positive.

* If there is no limit, then d.maxlen == -1.

*

* After an item is added to a deque, we check to see if the size has grown past

* the limit. If it has, we get the size back down to the limit by popping an

* item off of the opposite end. The methods that can trigger this are append(),

* appendleft(), extend(), and extendleft().

*/

static void

deque_trim_right(dequeobject *deque)

{

if (deque->maxlen != -1 && Py_SIZE(deque) > deque->maxlen) {

PyObject *rv = deque_pop(deque, NULL);

assert(rv != NULL);

assert(Py_SIZE(deque) <= deque->maxlen);

Py_DECREF(rv);

}

}

static void

deque_trim_left(dequeobject *deque)

{

if (deque->maxlen != -1 && Py_SIZE(deque) > deque->maxlen) {

PyObject *rv = deque_popleft(deque, NULL);

assert(rv != NULL);

assert(Py_SIZE(deque) <= deque->maxlen);

Py_DECREF(rv);

}

}

static PyObject *

deque_append(dequeobject *deque, PyObject *item)

{

deque->state++;

if (deque->rightindex == BLOCKLEN - 1) {

block *b = newblock(Py_SIZE(deque));

if (b == NULL)

return NULL;

b->leftlink = deque->rightblock;

CHECK_END(deque->rightblock->rightlink);

deque->rightblock->rightlink = b;

deque->rightblock = b;

MARK_END(b->rightlink);

deque->rightindex = -1;

}

Py_INCREF(item);

Py_SIZE(deque)++;

deque->rightindex++;

deque->rightblock->data[deque->rightindex] = item;

deque_trim_left(deque);

Py_RETURN_NONE;

}

PyDoc_STRVAR(append_doc, "Add an element to the right side of the deque.");

static PyObject *

deque_appendleft(dequeobject *deque, PyObject *item)

{

deque->state++;

if (deque->leftindex == 0) {

block *b = newblock(Py_SIZE(deque));

if (b == NULL)

return NULL;

b->rightlink = deque->leftblock;

CHECK_END(deque->leftblock->leftlink);

deque->leftblock->leftlink = b;

deque->leftblock = b;

MARK_END(b->leftlink);

deque->leftindex = BLOCKLEN;

}

Py_INCREF(item);

Py_SIZE(deque)++;

deque->leftindex--;

deque->leftblock->data[deque->leftindex] = item;

deque_trim_right(deque);

Py_RETURN_NONE;

}

PyDoc_STRVAR(appendleft_doc, "Add an element to the left side of the deque.");

/* Run an iterator to exhaustion. Shortcut for

the extend/extendleft methods when maxlen == 0. */

static PyObject*

consume_iterator(PyObject *it)

{

PyObject *item;

while ((item = PyIter_Next(it)) != NULL) {

Py_DECREF(item);

}

Py_DECREF(it);

if (PyErr_Occurred())

return NULL;

Py_RETURN_NONE;

}

static PyObject *

deque_extend(dequeobject *deque, PyObject *iterable)

{

PyObject *it, *item;

/* Handle case where id(deque) == id(iterable) */

if ((PyObject *)deque == iterable) {

PyObject *result;

PyObject *s = PySequence_List(iterable);

if (s == NULL)

return NULL;

result = deque_extend(deque, s);

Py_DECREF(s);

return result;

}

/* Space saving heuristic. Start filling from the left */

if (Py_SIZE(deque) == 0) {

assert(deque->leftblock == deque->rightblock);

assert(deque->leftindex == deque->rightindex+1);

deque->leftindex = 1;

deque->rightindex = 0;

}

it = PyObject_GetIter(iterable);

if (it == NULL)

return NULL;

if (deque->maxlen == 0)

return consume_iterator(it);

while ((item = PyIter_Next(it)) != NULL) {

deque->state++;

if (deque->rightindex == BLOCKLEN - 1) {

block *b = newblock(Py_SIZE(deque));

if (b == NULL) {

Py_DECREF(item);

Py_DECREF(it);

return NULL;

}

b->leftlink = deque->rightblock;

CHECK_END(deque->rightblock->rightlink);

deque->rightblock->rightlink = b;

deque->rightblock = b;

MARK_END(b->rightlink);

deque->rightindex = -1;

}

Py_SIZE(deque)++;

deque->rightindex++;

deque->rightblock->data[deque->rightindex] = item;

deque_trim_left(deque);

}

if (PyErr_Occurred()) {

Py_DECREF(it);

return NULL;

}

Py_DECREF(it);

Py_RETURN_NONE;

}

PyDoc_STRVAR(extend_doc,

"Extend the right side of the deque with elements from the iterable");

static PyObject *

deque_extendleft(dequeobject *deque, PyObject *iterable)

{

PyObject *it, *item;

/* Handle case where id(deque) == id(iterable) */

if ((PyObject *)deque == iterable) {

PyObject *result;

PyObject *s = PySequence_List(iterable);

if (s == NULL)

return NULL;

result = deque_extendleft(deque, s);

Py_DECREF(s);

return result;

}

/* Space saving heuristic. Start filling from the right */

if (Py_SIZE(deque) == 0) {

assert(deque->leftblock == deque->rightblock);

assert(deque->leftindex == deque->rightindex+1);

deque->leftindex = BLOCKLEN - 1;

deque->rightindex = BLOCKLEN - 2;

}

it = PyObject_GetIter(iterable);

if (it == NULL)

return NULL;

if (deque->maxlen == 0)

return consume_iterator(it);

while ((item = PyIter_Next(it)) != NULL) {

deque->state++;

if (deque->leftindex == 0) {

block *b = newblock(Py_SIZE(deque));

if (b == NULL) {

Py_DECREF(item);

Py_DECREF(it);

return NULL;

}

b->rightlink = deque->leftblock;

CHECK_END(deque->leftblock->leftlink);

deque->leftblock->leftlink = b;

deque->leftblock = b;

MARK_END(b->leftlink);

deque->leftindex = BLOCKLEN;

}

Py_SIZE(deque)++;

deque->leftindex--;

deque->leftblock->data[deque->leftindex] = item;

deque_trim_right(deque);

}

if (PyErr_Occurred()) {

Py_DECREF(it);

return NULL;

}

Py_DECREF(it);

Py_RETURN_NONE;

}

PyDoc_STRVAR(extendleft_doc,

"Extend the left side of the deque with elements from the iterable");

static PyObject *

deque_inplace_concat(dequeobject *deque, PyObject *other)

{

PyObject *result;

result = deque_extend(deque, other);

if (result == NULL)

return result;

Py_INCREF(deque);

Py_DECREF(result);

return (PyObject *)deque;

}

static PyObject *deque_copy(PyObject *deque);

static PyObject *

deque_concat(dequeobject *deque, PyObject *other)

{

PyObject *new_deque, *result;

int rv;

rv = PyObject_IsInstance(other, (PyObject *)&deque_type);

if (rv <= 0) {

if (rv == 0) {

PyErr_Format(PyExc_TypeError,

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

other->ob_type->tp_name);

}

return NULL;

}

new_deque = deque_copy((PyObject *)deque);

if (new_deque == NULL)

return NULL;

result = deque_extend((dequeobject *)new_deque, other);

if (result == NULL) {

Py_DECREF(new_deque);

return NULL;

}

Py_DECREF(result);

return new_deque;

}

static void deque_clear(dequeobject *deque);

static PyObject *

deque_repeat(dequeobject *deque, Py_ssize_t n)

{

dequeobject *new_deque;

PyObject *result;

/* XXX add a special case for when maxlen is defined */

if (n < 0)

n = 0;

else if (n > 0 && Py_SIZE(deque) > MAX_DEQUE_LEN / n)

return PyErr_NoMemory();

new_deque = (dequeobject *)deque_new(&deque_type, (PyObject *)NULL, (PyObject *)NULL);

new_deque->maxlen = deque->maxlen;

for ( ; n ; n--) {

result = deque_extend(new_deque, (PyObject *)deque);

if (result == NULL) {

Py_DECREF(new_deque);

return NULL;

}

Py_DECREF(result);

}

return (PyObject *)new_deque;

}

static PyObject *

deque_inplace_repeat(dequeobject *deque, Py_ssize_t n)

{

Py_ssize_t i, size;

PyObject *seq;

PyObject *rv;

size = Py_SIZE(deque);

if (size == 0 || n == 1) {

Py_INCREF(deque);

return (PyObject *)deque;

}

if (n <= 0) {

deque_clear(deque);

Py_INCREF(deque);

return (PyObject *)deque;

}

if (size > MAX_DEQUE_LEN / n) {

return PyErr_NoMemory();

}

if (size == 1) {

/* common case, repeating a single element */

PyObject *item = deque->leftblock->data[deque->leftindex];

if (deque->maxlen != -1 && n > deque->maxlen)

n = deque->maxlen;

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

rv = deque_append(deque, item);

if (rv == NULL)

return NULL;

Py_DECREF(rv);

}

Py_INCREF(deque);

return (PyObject *)deque;

}

seq = PySequence_List((PyObject *)deque);

if (seq == NULL)

return seq;

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

rv = deque_extend(deque, seq);

if (rv == NULL) {

Py_DECREF(seq);

return NULL;

}

Py_DECREF(rv);

}

Py_INCREF(deque);

Py_DECREF(seq);

return (PyObject *)deque;

}

/* The rotate() method is part of the public API and is used internally

as a primitive for other methods.

Rotation by 1 or -1 is a common case, so any optimizations for high

volume rotations should take care not to penalize the common case.

Conceptually, a rotate by one is equivalent to a pop on one side and an

append on the other. However, a pop/append pair is unnecessarily slow

because it requires an incref/decref pair for an object located randomly

in memory. It is better to just move the object pointer from one block

to the next without changing the reference count.

When moving batches of pointers, it is tempting to use memcpy() but that

proved to be slower than a simple loop for a variety of reasons.

Memcpy() cannot know in advance that we're copying pointers instead of

bytes, that the source and destination are pointer aligned and

non-overlapping, that moving just one pointer is a common case, that we

never need to move more than BLOCKLEN pointers, and that at least one

pointer is always moved.

For high volume rotations, newblock() and freeblock() are never called

more than once. Previously emptied blocks are immediately reused as a

destination block. If a block is left-over at the end, it is freed.

*/

static int

_deque_rotate(dequeobject *deque, Py_ssize_t n)

{

block *b = NULL;

block *leftblock = deque->leftblock;

block *rightblock = deque->rightblock;

Py_ssize_t leftindex = deque->leftindex;

Py_ssize_t rightindex = deque->rightindex;

Py_ssize_t len=Py_SIZE(deque), halflen=len>>1;

int rv = -1;

if (len <= 1)

return 0;

if (n > halflen || n < -halflen) {

n %= len;

if (n > halflen)

n -= len;

else if (n < -halflen)

n += len;

}

assert(len > 1);

assert(-halflen <= n && n <= halflen);

deque->state++;

while (n > 0) {

if (leftindex == 0) {

if (b == NULL) {

b = newblock(len);

if (b == NULL)

goto done;

}

b->rightlink = leftblock;

CHECK_END(leftblock->leftlink);

leftblock->leftlink = b;

leftblock = b;

MARK_END(b->leftlink);

leftindex = BLOCKLEN;

b = NULL;

}

assert(leftindex > 0);

{

PyObject **src, **dest;

Py_ssize_t m = n;

if (m > rightindex + 1)

m = rightindex + 1;

if (m > leftindex)

m = leftindex;

assert (m > 0 && m <= len);

rightindex -= m;

leftindex -= m;

src = &rightblock->data[rightindex + 1];

dest = &leftblock->data[leftindex];

n -= m;

do {

*(dest++) = *(src++);

} while (--m);

}

if (rightindex == -1) {

assert(leftblock != rightblock);

assert(b == NULL);

b = rightblock;

CHECK_NOT_END(rightblock->leftlink);

rightblock = rightblock->leftlink;

MARK_END(rightblock->rightlink);

rightindex = BLOCKLEN - 1;

}

}

while (n < 0) {

if (rightindex == BLOCKLEN - 1) {

if (b == NULL) {

b = newblock(len);

if (b == NULL)

goto done;

}

b->leftlink = rightblock;

CHECK_END(rightblock->rightlink);

rightblock->rightlink = b;

rightblock = b;

MARK_END(b->rightlink);

rightindex = -1;

b = NULL;

}

assert (rightindex < BLOCKLEN - 1);

{

PyObject **src, **dest;

Py_ssize_t m = -n;

if (m > BLOCKLEN - leftindex)

m = BLOCKLEN - leftindex;

if (m > BLOCKLEN - 1 - rightindex)

m = BLOCKLEN - 1 - rightindex;

assert (m > 0 && m <= len);

src = &leftblock->data[leftindex];

dest = &rightblock->data[rightindex + 1];

leftindex += m;

rightindex += m;

n += m;

do {

*(dest++) = *(src++);

} while (--m);

}

if (leftindex == BLOCKLEN) {

assert(leftblock != rightblock);

assert(b == NULL);

b = leftblock;

CHECK_NOT_END(leftblock->rightlink);

leftblock = leftblock->rightlink;

MARK_END(leftblock->leftlink);

leftindex = 0;

}

}

rv = 0;

done:

if (b != NULL)

freeblock(b);

deque->leftblock = leftblock;

deque->rightblock = rightblock;

deque->leftindex = leftindex;

deque->rightindex = rightindex;

return rv;

}

static PyObject *

deque_rotate(dequeobject *deque, PyObject *args)

{

Py_ssize_t n=1;

if (!PyArg_ParseTuple(args, "|n:rotate", &n))

return NULL;

if (!_deque_rotate(deque, n))

Py_RETURN_NONE;

return NULL;

}

PyDoc_STRVAR(rotate_doc,

"Rotate the deque n steps to the right (default n=1). If n is negative, rotates left.");

static PyObject *

deque_reverse(dequeobject *deque, PyObject *unused)

{

block *leftblock = deque->leftblock;

block *rightblock = deque->rightblock;

Py_ssize_t leftindex = deque->leftindex;

Py_ssize_t rightindex = deque->rightindex;

Py_ssize_t n = Py_SIZE(deque) / 2;

Py_ssize_t i;

PyObject *tmp;

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

/* Validate that pointers haven't met in the middle */

assert(leftblock != rightblock || leftindex < rightindex);

CHECK_NOT_END(leftblock);

CHECK_NOT_END(rightblock);

/* Swap */

tmp = leftblock->data[leftindex];

leftblock->data[leftindex] = rightblock->data[rightindex];

rightblock->data[rightindex] = tmp;

/* Advance left block/index pair */

leftindex++;

if (leftindex == BLOCKLEN) {

leftblock = leftblock->rightlink;

leftindex = 0;

}

/* Step backwards with the right block/index pair */

rightindex--;

if (rightindex == -1) {

rightblock = rightblock->leftlink;

rightindex = BLOCKLEN - 1;

}

}

Py_RETURN_NONE;

}

PyDoc_STRVAR(reverse_doc,

"D.reverse() -- reverse *IN PLACE*");

static PyObject *

deque_count(dequeobject *deque, PyObject *v)

{

block *b = deque->leftblock;

Py_ssize_t index = deque->leftindex;

Py_ssize_t n = Py_SIZE(deque);

Py_ssize_t i;

Py_ssize_t count = 0;

size_t start_state = deque->state;

PyObject *item;

int cmp;

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

CHECK_NOT_END(b);

item = b->data[index];

cmp = PyObject_RichCompareBool(item, v, Py_EQ);

if (cmp > 0)

count++;

else if (cmp < 0)

return NULL;

if (start_state != deque->state) {

PyErr_SetString(PyExc_RuntimeError,

"deque mutated during iteration");

return NULL;

}

/* Advance left block/index pair */

index++;

if (index == BLOCKLEN) {

b = b->rightlink;

index = 0;

}

}

return PyLong_FromSsize_t(count);

}

PyDoc_STRVAR(count_doc,

"D.count(value) -> integer -- return number of occurrences of value");

static int

deque_contains(dequeobject *deque, PyObject *v)

{

block *b = deque->leftblock;

Py_ssize_t index = deque->leftindex;

Py_ssize_t n = Py_SIZE(deque);

Py_ssize_t i;

size_t start_state = deque->state;

PyObject *item;

int cmp;

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

CHECK_NOT_END(b);

item = b->data[index];

cmp = PyObject_RichCompareBool(item, v, Py_EQ);

if (cmp) {

return cmp;

}

if (start_state != deque->state) {

PyErr_SetString(PyExc_RuntimeError,

"deque mutated during iteration");

return -1;

}

index++;

if (index == BLOCKLEN) {

b = b->rightlink;

index = 0;

}

}

return 0;

}

static Py_ssize_t

deque_len(dequeobject *deque)

{

return Py_SIZE(deque);

}

static PyObject *

deque_index(dequeobject *deque, PyObject *args)

{

Py_ssize_t i, start=0, stop=Py_SIZE(deque);

PyObject *v, *item;

block *b = deque->leftblock;

Py_ssize_t index = deque->leftindex;

size_t start_state = deque->state;

if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,

_PyEval_SliceIndexNotNone, &start,

_PyEval_SliceIndexNotNone, &stop))

return NULL;

if (start < 0) {

start += Py_SIZE(deque);

if (start < 0)

start = 0;

}

if (stop < 0) {

stop += Py_SIZE(deque);

if (stop < 0)

stop = 0;

}

if (stop > Py_SIZE(deque))

stop = Py_SIZE(deque);

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

if (i >= start) {

int cmp;

CHECK_NOT_END(b);

item = b->data[index];

cmp = PyObject_RichCompareBool(item, v, Py_EQ);

if (cmp > 0)

return PyLong_FromSsize_t(i);

else if (cmp < 0)

return NULL;

if (start_state != deque->state) {

PyErr_SetString(PyExc_RuntimeError,

"deque mutated during iteration");

return NULL;

}

}

index++;

if (index == BLOCKLEN) {

b = b->rightlink;

index = 0;

}

}

PyErr_Format(PyExc_ValueError, "%R is not in deque", v);

return NULL;

}

PyDoc_STRVAR(index_doc,

"D.index(value, [start, [stop]]) -> integer -- return first index of value.\n"

"Raises ValueError if the value is not present.");

/* insert(), remove(), and delitem() are implemented in terms of

rotate() for simplicity and reasonable performance near the end

points. If for some reason these methods become popular, it is not

hard to re-implement this using direct data movement (similar to

the code used in list slice assignments) and achieve a performance

boost (by moving each pointer only once instead of twice).

*/

static PyObject *

deque_insert(dequeobject *deque, PyObject *args)

{

Py_ssize_t index;

Py_ssize_t n = Py_SIZE(deque);

PyObject *value;

PyObject *rv;

if (!PyArg_ParseTuple(args, "nO:insert", &index, &value))

return NULL;

if (deque->maxlen == Py_SIZE(deque)) {

PyErr_SetString(PyExc_IndexError, "deque already at its maximum size");

return NULL;

}

if (index >= n)

return deque_append(deque, value);

if (index <= -n || index == 0)

return deque_appendleft(deque, value);

if (_deque_rotate(deque, -index))

return NULL;

if (index < 0)

rv = deque_append(deque, value);

else

rv = deque_appendleft(deque, value);

if (rv == NULL)

return NULL;

Py_DECREF(rv);

if (_deque_rotate(deque, index))

return NULL;

Py_RETURN_NONE;

}