#include "Python.h"

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

#include "pycore_ceval.h" // _PyEval_GetBuiltin()

#include "pycore_critical_section.h" //_Py_BEGIN_CRITICAL_SECTION

#include "pycore_dict.h" // _Py_dict_lookup()

#include "pycore_object.h" // _PyObject_GC_UNTRACK()

#include "pycore_pyerrors.h" // _PyErr_ChainExceptions1()

#include "pycore_tuple.h" // _PyTuple_Recycle()

#include <stddef.h> // offsetof()

#include "pycore_weakref.h" // FT_CLEAR_WEAKREFS()

#include "clinic/odictobject.c.h"

typedef struct _odictnode _ODictNode;

struct _odictobject {

};

#define _PyODictObject_CAST(op) _Py_CAST(PyODictObject*, (op))

struct _odictnode {

};

#define _odictnode_KEY(node) \

(node->key)

#define _odictnode_HASH(node) \

(node->hash)

#define _odictnode_VALUE(node, od) \

PyODict_GetItemWithError((PyObject *)od, _odictnode_KEY(node))

#define _odictnode_PREV(node) (node->prev)

#define _odictnode_NEXT(node) (node->next)

#define _odict_FIRST(od) (_PyODictObject_CAST(od)->od_first)

#define _odict_LAST(od) (_PyODictObject_CAST(od)->od_last)

#define _odict_EMPTY(od) (_odict_FIRST(od) == NULL)

#define _odict_FOREACH(od, node) \

for (node = _odict_FIRST(od); node != NULL; node = _odictnode_NEXT(node))

static Py_ssize_t

_odict_get_index_raw(PyODictObject *od, PyObject *key, Py_hash_t hash)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(od);

PyObject *value = NULL;

PyDictKeysObject *keys = ((PyDictObject *)od)->ma_keys;

Py_ssize_t ix;

#ifdef Py_GIL_DISABLED

ix = _Py_dict_lookup_threadsafe((PyDictObject *)od, key, hash, &value);

Py_XDECREF(value);

ix = _Py_dict_lookup((PyDictObject *)od, key, hash, &value);

if (ix == DKIX_EMPTY) {

return keys->dk_nentries; /* index of new entry */

}

if (ix < 0)

return -1;

/* We use pointer arithmetic to get the entry's index into the table. */

return ix;

}

#define ONE ((Py_ssize_t)1)

static int

_odict_resize(PyODictObject *od)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(od);

Py_ssize_t size, i;

_ODictNode **fast_nodes, *node;

/* Initialize a new "fast nodes" table. */

size = ONE << (((PyDictObject *)od)->ma_keys->dk_log2_size);

fast_nodes = PyMem_NEW(_ODictNode *, size);

if (fast_nodes == NULL) {

PyErr_NoMemory();

return -1;

}

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

fast_nodes[i] = NULL;

/* Copy the current nodes into the table. */

_odict_FOREACH(od, node) {

i = _odict_get_index_raw(od, _odictnode_KEY(node),

_odictnode_HASH(node));

if (i < 0) {

PyMem_Free(fast_nodes);

return -1;

}

fast_nodes[i] = node;

}

/* Replace the old fast nodes table. */

PyMem_Free(od->od_fast_nodes);

od->od_fast_nodes = fast_nodes;

od->od_fast_nodes_size = size;

od->od_resize_sentinel = ((PyDictObject *)od)->ma_keys;

return 0;

}

static Py_ssize_t

_odict_get_index(PyODictObject *od, PyObject *key, Py_hash_t hash)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(od);

PyDictKeysObject *keys;

assert(key != NULL);

keys = ((PyDictObject *)od)->ma_keys;

/* Ensure od_fast_nodes and dk_entries are in sync. */

if (od->od_resize_sentinel != keys ||

od->od_fast_nodes_size != (ONE << (keys->dk_log2_size))) {

int resize_res = _odict_resize(od);

if (resize_res < 0)

return -1;

}

return _odict_get_index_raw(od, key, hash);

}

static _ODictNode *

_odict_find_node_hash(PyODictObject *od, PyObject *key, Py_hash_t hash)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(od);

Py_ssize_t index;

if (_odict_EMPTY(od))

return NULL;

index = _odict_get_index(od, key, hash);

if (index < 0)

return NULL;

assert(od->od_fast_nodes != NULL);

return od->od_fast_nodes[index];

}

static _ODictNode *

_odict_find_node(PyODictObject *od, PyObject *key)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(od);

Py_ssize_t index;

Py_hash_t hash;

if (_odict_EMPTY(od))

return NULL;

hash = PyObject_Hash(key);

if (hash == -1)

return NULL;

index = _odict_get_index(od, key, hash);

if (index < 0)

return NULL;

assert(od->od_fast_nodes != NULL);

return od->od_fast_nodes[index];

}

static void

_odict_add_head(PyODictObject *od, _ODictNode *node)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(od);

_odictnode_PREV(node) = NULL;

_odictnode_NEXT(node) = _odict_FIRST(od);

if (_odict_FIRST(od) == NULL)

_odict_LAST(od) = node;

else

_odictnode_PREV(_odict_FIRST(od)) = node;

_odict_FIRST(od) = node;

od->od_state++;

}

static void

_odict_add_tail(PyODictObject *od, _ODictNode *node)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(od);

_odictnode_PREV(node) = _odict_LAST(od);

_odictnode_NEXT(node) = NULL;

if (_odict_LAST(od) == NULL)

_odict_FIRST(od) = node;

else

_odictnode_NEXT(_odict_LAST(od)) = node;

_odict_LAST(od) = node;

od->od_state++;

}

static int

_odict_add_new_node(PyODictObject *od, PyObject *key, Py_hash_t hash)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(od);

Py_ssize_t i;

_ODictNode *node;

Py_INCREF(key);

i = _odict_get_index(od, key, hash);

if (i < 0) {

if (!PyErr_Occurred())

PyErr_SetObject(PyExc_KeyError, key);

Py_DECREF(key);

return -1;

}

assert(od->od_fast_nodes != NULL);

if (od->od_fast_nodes[i] != NULL) {

/* We already have a node for the key so there's no need to add one. */

Py_DECREF(key);

return 0;

}

/* must not be added yet */

node = (_ODictNode *)PyMem_Malloc(sizeof(_ODictNode));

if (node == NULL) {

Py_DECREF(key);

PyErr_NoMemory();

return -1;

}

_odictnode_KEY(node) = key;

_odictnode_HASH(node) = hash;

_odict_add_tail(od, node);

od->od_fast_nodes[i] = node;

return 0;

}

#define _odictnode_DEALLOC(node) \

do { \

Py_DECREF(_odictnode_KEY(node)); \

PyMem_Free((void *)node); \

} while (0)

static void

_odict_remove_node(PyODictObject *od, _ODictNode *node)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(od);

if (_odict_FIRST(od) == node)

_odict_FIRST(od) = _odictnode_NEXT(node);

else if (_odictnode_PREV(node) != NULL)

_odictnode_NEXT(_odictnode_PREV(node)) = _odictnode_NEXT(node);

if (_odict_LAST(od) == node)

_odict_LAST(od) = _odictnode_PREV(node);

else if (_odictnode_NEXT(node) != NULL)

_odictnode_PREV(_odictnode_NEXT(node)) = _odictnode_PREV(node);

_odictnode_PREV(node) = NULL;

_odictnode_NEXT(node) = NULL;

od->od_state++;

}

static int

_odict_clear_node(PyODictObject *od, _ODictNode *node, PyObject *key,

Py_hash_t hash)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(od);

Py_ssize_t i;

assert(key != NULL);

if (_odict_EMPTY(od)) {

/* Let later code decide if this is a KeyError. */

return 0;

}

i = _odict_get_index(od, key, hash);

if (i < 0)

return PyErr_Occurred() ? -1 : 0;

assert(od->od_fast_nodes != NULL);

if (node == NULL)

node = od->od_fast_nodes[i];

assert(node == od->od_fast_nodes[i]);

if (node == NULL) {

/* Let later code decide if this is a KeyError. */

return 0;

}

// Now clear the node.

od->od_fast_nodes[i] = NULL;

_odict_remove_node(od, node);

_odictnode_DEALLOC(node);

return 0;

}

static void

_odict_clear_nodes(PyODictObject *od)

{

_ODictNode *node, *next;

PyMem_Free(od->od_fast_nodes);

od->od_fast_nodes = NULL;

od->od_fast_nodes_size = 0;

od->od_resize_sentinel = NULL;

node = _odict_FIRST(od);

_odict_FIRST(od) = NULL;

_odict_LAST(od) = NULL;

while (node != NULL) {

next = _odictnode_NEXT(node);

_odictnode_DEALLOC(node);

node = next;

}

od->od_state++;

}

#undef _odictnode_DEALLOC

static int

_odict_keys_equal(PyODictObject *a, PyODictObject *b)

{

_ODictNode *node_a, *node_b;

// keep operands' state to detect undesired mutations

const size_t state_a = a->od_state;

const size_t state_b = b->od_state;

node_a = _odict_FIRST(a);

node_b = _odict_FIRST(b);

while (1) {

if (node_a == NULL && node_b == NULL) {

/* success: hit the end of each at the same time */

return 1;

}

else if (node_a == NULL || node_b == NULL) {

/* unequal length */

return 0;

}

else {

PyObject *key_a = Py_NewRef(_odictnode_KEY(node_a));

PyObject *key_b = Py_NewRef(_odictnode_KEY(node_b));

int res = PyObject_RichCompareBool(key_a, key_b, Py_EQ);

Py_DECREF(key_a);

Py_DECREF(key_b);

if (res < 0) {

return res;

}

else if (a->od_state != state_a || b->od_state != state_b) {

PyErr_SetString(PyExc_RuntimeError,

"OrderedDict mutated during iteration");

return -1;

}

else if (res == 0) {

// This check comes after the check on the state

// in order for the exception to be set correctly.

return 0;

}

/* otherwise it must match, so move on to the next one */

node_a = _odictnode_NEXT(node_a);

node_b = _odictnode_NEXT(node_b);

}

}

}

static int

odict_mp_ass_sub(PyObject *od, PyObject *v, PyObject *w)

{

if (w == NULL)

return PyODict_DelItem(od, v);

else

return PyODict_SetItem(od, v, w);

}

static PyMappingMethods odict_as_mapping = {

0, /*mp_length*/

0, /*mp_subscript*/

odict_mp_ass_sub, /*mp_ass_subscript*/

};

static int mutablemapping_update_arg(PyObject*, PyObject*);

static PyObject *

odict_or(PyObject *left, PyObject *right)

{

PyTypeObject *type;

PyObject *other;

if (PyODict_Check(left)) {

type = Py_TYPE(left);

other = right;

}

else {

type = Py_TYPE(right);

other = left;

}

if (!PyAnyDict_Check(other)) {

Py_RETURN_NOTIMPLEMENTED;

}

PyObject *new = PyObject_CallOneArg((PyObject*)type, left);

if (!new) {

return NULL;

}

if (mutablemapping_update_arg(new, right) < 0) {

Py_DECREF(new);

return NULL;

}

return new;

}

static PyObject *

odict_inplace_or(PyObject *self, PyObject *other)

{

if (mutablemapping_update_arg(self, other) < 0) {

return NULL;

}

return Py_NewRef(self);

}

static PyNumberMethods odict_as_number = {

.nb_or = odict_or,

.nb_inplace_or = odict_inplace_or,

};

static PyObject *

OrderedDict_fromkeys_impl(PyTypeObject *type, PyObject *seq, PyObject *value)

{

return _PyDict_FromKeys((PyObject *)type, seq, value);

}

static Py_ssize_t

OrderedDict___sizeof___impl(PyODictObject *self)

{

Py_ssize_t res = _PyDict_SizeOf_LockHeld((PyDictObject *)self);

res += sizeof(_ODictNode *) * self->od_fast_nodes_size; /* od_fast_nodes */

if (!_odict_EMPTY(self)) {

res += sizeof(_ODictNode) * PyODict_SIZE(self); /* linked-list */

}

return res;

}

static PyObject *

OrderedDict___reduce___impl(PyODictObject *od)

{

PyObject *state, *result = NULL;

PyObject *items_iter, *items, *args = NULL;

/* capture any instance state */

state = _PyObject_GetState((PyObject *)od);

if (state == NULL)

goto Done;

/* build the result */