#include "Python.h"

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_long.h" // _PyLong_GetZero()

#include "structmember.h" // PyMemberDef

#include <stddef.h>

static PyTypeObject tuplegetter_type;

#include "clinic/_collectionsmodule.c.h"

#define BLOCKLEN 64

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

#define MAXFREEBLOCKS 16

typedef struct BLOCK {

} 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; /* maxlen is -1 for unbounded deques */

Py_ssize_t numfreeblocks;

block *freeblocks[MAXFREEBLOCKS];

PyObject *weakreflist;

} dequeobject;

static PyTypeObject deque_type;

#ifndef NDEBUG

#define MARK_END(link) link = NULL;

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

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

#define MARK_END(link)

#define CHECK_END(link)

#define CHECK_NOT_END(link)

static inline block *

newblock(dequeobject *deque) {

block *b;

if (deque->numfreeblocks) {

deque->numfreeblocks--;

return deque->freeblocks[deque->numfreeblocks];

}

b = PyMem_Malloc(sizeof(block));

if (b != NULL) {

return b;

}

PyErr_NoMemory();

return NULL;

}

static inline void

freeblock(dequeobject *deque, block *b)

{

if (deque->numfreeblocks < MAXFREEBLOCKS) {

deque->freeblocks[deque->numfreeblocks] = b;

deque->numfreeblocks++;

} else {

PyMem_Free(b);

}

}

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(deque);

if (b == NULL) {

Py_DECREF(deque);

return NULL;

}

MARK_END(b->leftlink);

MARK_END(b->rightlink);

assert(BLOCKLEN >= 2);

Py_SET_SIZE(deque, 0);

deque->leftblock = b;

deque->rightblock = b;

deque->leftindex = CENTER + 1;

deque->rightindex = CENTER;

deque->state = 0;

deque->maxlen = -1;

deque->numfreeblocks = 0;

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_SET_SIZE(deque, Py_SIZE(deque) - 1);

deque->state++;

if (deque->rightindex < 0) {

if (Py_SIZE(deque)) {

prevblock = deque->rightblock->leftlink;

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

freeblock(deque, 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_SET_SIZE(deque, Py_SIZE(deque) - 1);

deque->state++;

if (deque->leftindex == BLOCKLEN) {

if (Py_SIZE(deque)) {

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

prevblock = deque->leftblock->rightlink;

freeblock(deque, 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.");

#define NEEDS_TRIM(deque, maxlen) ((size_t)(maxlen) < (size_t)(Py_SIZE(deque)))

static inline int

deque_append_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen)

{

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

block *b = newblock(deque);

if (b == NULL)

return -1;

b->leftlink = deque->rightblock;

CHECK_END(deque->rightblock->rightlink);

deque->rightblock->rightlink = b;

deque->rightblock = b;

MARK_END(b->rightlink);

deque->rightindex = -1;

}

Py_SET_SIZE(deque, Py_SIZE(deque) + 1);

deque->rightindex++;

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

if (NEEDS_TRIM(deque, maxlen)) {

PyObject *olditem = deque_popleft(deque, NULL);

Py_DECREF(olditem);

} else {

deque->state++;

}

return 0;

}

static PyObject *

deque_append(dequeobject *deque, PyObject *item)

{

if (deque_append_internal(deque, Py_NewRef(item), deque->maxlen) < 0)

return NULL;

Py_RETURN_NONE;

}

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

static inline int

deque_appendleft_internal(dequeobject *deque, PyObject *item, Py_ssize_t maxlen)

{

if (deque->leftindex == 0) {

block *b = newblock(deque);

if (b == NULL)

return -1;

b->rightlink = deque->leftblock;

CHECK_END(deque->leftblock->leftlink);

deque->leftblock->leftlink = b;

deque->leftblock = b;

MARK_END(b->leftlink);

deque->leftindex = BLOCKLEN;

}

Py_SET_SIZE(deque, Py_SIZE(deque) + 1);

deque->leftindex--;

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

if (NEEDS_TRIM(deque, deque->maxlen)) {

PyObject *olditem = deque_pop(deque, NULL);

Py_DECREF(olditem);

} else {

deque->state++;

}

return 0;

}

static PyObject *

deque_appendleft(dequeobject *deque, PyObject *item)

{

if (deque_appendleft_internal(deque, Py_NewRef(item), deque->maxlen) < 0)

return NULL;

Py_RETURN_NONE;

}

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

static PyObject*

finalize_iterator(PyObject *it)

{

if (PyErr_Occurred()) {

if (PyErr_ExceptionMatches(PyExc_StopIteration))

PyErr_Clear();

else {

Py_DECREF(it);

return NULL;

}

}

Py_DECREF(it);

Py_RETURN_NONE;

}

static PyObject*

consume_iterator(PyObject *it)

{

PyObject *(*iternext)(PyObject *);

PyObject *item;

iternext = *Py_TYPE(it)->tp_iternext;

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

Py_DECREF(item);

}

return finalize_iterator(it);

}

static PyObject *

deque_extend(dequeobject *deque, PyObject *iterable)

{

PyObject *it, *item;

PyObject *(*iternext)(PyObject *);

Py_ssize_t maxlen = deque->maxlen;

/* 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;

}

it = PyObject_GetIter(iterable);

if (it == NULL)

return NULL;

if (maxlen == 0)

return consume_iterator(it);

/* 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;

}

iternext = *Py_TYPE(it)->tp_iternext;

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

if (deque_append_internal(deque, item, maxlen) == -1) {

Py_DECREF(item);

Py_DECREF(it);

return NULL;

}

}

return finalize_iterator(it);

}

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;

PyObject *(*iternext)(PyObject *);

Py_ssize_t maxlen = deque->maxlen;

/* 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;

}

it = PyObject_GetIter(iterable);

if (it == NULL)

return NULL;

if (maxlen == 0)

return consume_iterator(it);

/* 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;

}

iternext = *Py_TYPE(it)->tp_iternext;

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

if (deque_appendleft_internal(deque, item, maxlen) == -1) {

Py_DECREF(item);

Py_DECREF(it);

return NULL;

}

}

return finalize_iterator(it);

}

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, PyObject *Py_UNUSED(ignored))

{

PyObject *result;

dequeobject *old_deque = (dequeobject *)deque;

if (Py_IS_TYPE(deque, &deque_type)) {

dequeobject *new_deque;

PyObject *rv;

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

if (new_deque == NULL)

return NULL;

new_deque->maxlen = old_deque->maxlen;

/* Fast path for the deque_repeat() common case where len(deque) == 1 */

if (Py_SIZE(deque) == 1) {

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

rv = deque_append(new_deque, item);

} else {

rv = deque_extend(new_deque, deque);

}

if (rv != NULL) {

Py_DECREF(rv);

return (PyObject *)new_deque;

}

Py_DECREF(new_deque);

return NULL;

}

if (old_deque->maxlen < 0)

result = PyObject_CallOneArg((PyObject *)(Py_TYPE(deque)), deque);

else

result = PyObject_CallFunction((PyObject *)(Py_TYPE(deque)), "Oi",

deque, old_deque->maxlen, NULL);

if (result != NULL && !PyObject_TypeCheck(result, &deque_type)) {

PyErr_Format(PyExc_TypeError,

"%.200s() must return a deque, not %.200s",

Py_TYPE(deque)->tp_name, Py_TYPE(result)->tp_name);

Py_DECREF(result);

return NULL;

}

return result;

}

PyDoc_STRVAR(copy_doc, "Return a shallow copy of a 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",

Py_TYPE(other)->tp_name);

}

return NULL;

}

new_deque = deque_copy((PyObject *)deque, NULL);

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 int

deque_clear(dequeobject *deque)

{

block *b;

block *prevblock;

block *leftblock;

Py_ssize_t leftindex;

Py_ssize_t n, m;

PyObject *item;

PyObject **itemptr, **limit;

if (Py_SIZE(deque) == 0)

return 0;

/* During the process of clearing a deque, decrefs can cause the

b = newblock(deque);

if (b == NULL) {

PyErr_Clear();

goto alternate_method;

}

/* Remember the old size, leftblock, and leftindex */

n = Py_SIZE(deque);

leftblock = deque->leftblock;

leftindex = deque->leftindex;

/* Set the deque to be empty using the newly allocated block */

MARK_END(b->leftlink);

MARK_END(b->rightlink);

Py_SET_SIZE(deque, 0);

deque->leftblock = b;

deque->rightblock = b;

deque->leftindex = CENTER + 1;

deque->rightindex = CENTER;

deque->state++;

/* Now the old size, leftblock, and leftindex are disconnected from

m = (BLOCKLEN - leftindex > n) ? n : BLOCKLEN - leftindex;

itemptr = &leftblock->data[leftindex];

limit = itemptr + m;

n -= m;

while (1) {

if (itemptr == limit) {

if (n == 0)

break;

CHECK_NOT_END(leftblock->rightlink);

prevblock = leftblock;

leftblock = leftblock->rightlink;

m = (n > BLOCKLEN) ? BLOCKLEN : n;

itemptr = leftblock->data;

limit = itemptr + m;

n -= m;

freeblock(deque, prevblock);

}

item = *(itemptr++);

Py_DECREF(item);

}

CHECK_END(leftblock->rightlink);

freeblock(deque, leftblock);

return 0;

alternate_method:

while (Py_SIZE(deque)) {

item = deque_pop(deque, NULL);

assert (item != NULL);

Py_DECREF(item);

}

return 0;

}

static PyObject *

deque_clearmethod(dequeobject *deque, PyObject *Py_UNUSED(ignored))

{

deque_clear(deque);

Py_RETURN_NONE;

}

PyDoc_STRVAR(clear_doc, "Remove all elements from the deque.");

static PyObject *

deque_inplace_repeat(dequeobject *deque, Py_ssize_t n)

{

Py_ssize_t i, m, size;

PyObject *seq;

PyObject *rv;

size = Py_SIZE(deque);

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

return Py_NewRef(deque);

}

if (n <= 0) {

deque_clear(deque);

return Py_NewRef(deque);

}

if (size == 1) {

/* common case, repeating a single element */

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

if (deque->maxlen >= 0 && n > deque->maxlen)

n = deque->maxlen;

deque->state++;

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

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

block *b = newblock(deque);

if (b == NULL) {

Py_SET_SIZE(deque, Py_SIZE(deque) + i);

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;

}

m = n - 1 - i;

if (m > BLOCKLEN - 1 - deque->rightindex)

m = BLOCKLEN - 1 - deque->rightindex;

i += m;

while (m--) {

deque->rightindex++;

deque->rightblock->data[deque->rightindex] = Py_NewRef(item);

}

}

Py_SET_SIZE(deque, Py_SIZE(deque) + i);

return Py_NewRef(deque);

}

if ((size_t)size > PY_SSIZE_T_MAX / (size_t)n) {

return PyErr_NoMemory();

}

seq = PySequence_List((PyObject *)deque);

if (seq == NULL)

return seq;

/* Reduce the number of repetitions when maxlen would be exceeded */

if (deque->maxlen >= 0 && n * size > deque->maxlen)

n = (deque->maxlen + size - 1) / size;

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;

}

static PyObject *

deque_repeat(dequeobject *deque, Py_ssize_t n)

{

dequeobject *new_deque;

PyObject *rv;

new_deque = (dequeobject *)deque_copy((PyObject *) deque, NULL);

if (new_deque == NULL)

return NULL;

rv = deque_inplace_repeat(new_deque, n);

Py_DECREF(new_deque);

return rv;

}

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(deque);

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 < 0) {

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(deque);

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(deque, b);

deque->leftblock = leftblock;

deque->rightblock = rightblock;

deque->leftindex = leftindex;

deque->rightindex = rightindex;

return rv;

}

static PyObject *

deque_rotate(dequeobject *deque, PyObject *const *args, Py_ssize_t nargs)

{

Py_ssize_t n=1;

if (!_PyArg_CheckPositional("deque.rotate", nargs, 0, 1)) {

return NULL;

}

if (nargs) {

PyObject *index = _PyNumber_Index(args[0]);

if (index == NULL) {

return NULL;

}

n = PyLong_AsSsize_t(index);

Py_DECREF(index);

if (n == -1 && PyErr_Occurred()) {

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) >> 1;

PyObject *tmp;

while (--n >= 0) {

/* 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 < 0) {

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 count = 0;

size_t start_state = deque->state;

PyObject *item;

int cmp;

while (--n >= 0) {

CHECK_NOT_END(b);

item = Py_NewRef(b->data[index]);

cmp = PyObject_RichCompareBool(item, v, Py_EQ);

Py_DECREF(item);

if (cmp < 0)

return NULL;

count += cmp;

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);