#include "Python.h"

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

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

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

#include "pycore_moduleobject.h" // _PyModule_GetState()

#include "pycore_object.h" // _PyObject_GC_TRACK

#include "pycore_pyatomic_ft_wrappers.h"

#include "pycore_pystate.h" // _PyThreadState_GET()

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

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

#include "clinic/_functoolsmodule.c.h"

typedef struct _functools_state {

} _functools_state;

static inline _functools_state *

get_functools_state(PyObject *module)

{

void *state = _PyModule_GetState(module);

assert(state != NULL);

return (_functools_state *)state;

}

typedef struct {

PyObject_HEAD

} placeholderobject;

static inline _functools_state *

get_functools_state_by_type(PyTypeObject *type);

typedef struct {

PyObject_HEAD

PyObject *fn;

PyObject *args;

PyObject *kw;

PyObject *dict; /* __dict__ */

PyObject *weakreflist; /* List of weak references */

PyObject *placeholder; /* Placeholder for positional arguments */

Py_ssize_t phcount; /* Number of placeholders */

vectorcallfunc vectorcall;

} partialobject;

#define partialobject_CAST(op) ((partialobject *)(op))

static void partial_setvectorcall(partialobject *pto);

static struct PyModuleDef _functools_module;

static PyObject *

partial_call(PyObject *pto, PyObject *args, PyObject *kwargs);

static inline _functools_state *

get_functools_state_by_type(PyTypeObject *type)

{

PyObject *module = PyType_GetModuleByDef(type, &_functools_module);

if (module == NULL) {

return NULL;

}

return get_functools_state(module);

}

static PyObject *

partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)

{

PyObject *func, *pto_args, *new_args, *pto_kw, *phold;

partialobject *pto;

Py_ssize_t pto_phcount = 0;

Py_ssize_t new_nargs = PyTuple_GET_SIZE(args) - 1;

if (new_nargs < 0) {

PyErr_SetString(PyExc_TypeError,

"type 'partial' takes at least one argument");

return NULL;

}

func = PyTuple_GET_ITEM(args, 0);

if (!PyCallable_Check(func)) {

PyErr_SetString(PyExc_TypeError,

"the first argument must be callable");

return NULL;

}

_functools_state *state = get_functools_state_by_type(type);

if (state == NULL) {

return NULL;

}

phold = state->placeholder;

/* Placeholder restrictions */

if (new_nargs && PyTuple_GET_ITEM(args, new_nargs) == phold) {

PyErr_SetString(PyExc_TypeError,

"trailing Placeholders are not allowed");

return NULL;

}

/* keyword Placeholder prohibition */

if (kw != NULL) {

PyObject *key, *val;

Py_ssize_t pos = 0;

while (PyDict_Next(kw, &pos, &key, &val)) {

if (val == phold) {

PyErr_SetString(PyExc_TypeError,

"Placeholder cannot be passed as a keyword argument");

return NULL;

}

}

}

/* check wrapped function / object */

pto_args = pto_kw = NULL;

int res = PyObject_TypeCheck(func, state->partial_type);

if (res == -1) {

return NULL;

}

if (res == 1) {

// We can use its underlying function directly and merge the arguments.

partialobject *part = (partialobject *)func;

if (part->dict == NULL) {

pto_args = part->args;

pto_kw = part->kw;

func = part->fn;

pto_phcount = part->phcount;

assert(PyTuple_Check(pto_args));

assert(PyDict_Check(pto_kw));

}

}

/* create partialobject structure */

pto = (partialobject *)type->tp_alloc(type, 0);

if (pto == NULL)

return NULL;

pto->fn = Py_NewRef(func);

pto->placeholder = phold;

new_args = PyTuple_GetSlice(args, 1, new_nargs + 1);

if (new_args == NULL) {

Py_DECREF(pto);

return NULL;

}

/* Count placeholders */

Py_ssize_t phcount = 0;

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

if (PyTuple_GET_ITEM(new_args, i) == phold) {

phcount++;

}

}

/* merge args with args of `func` which is `partial` */

if (pto_phcount > 0 && new_nargs > 0) {

Py_ssize_t npargs = PyTuple_GET_SIZE(pto_args);

Py_ssize_t tot_nargs = npargs;

if (new_nargs > pto_phcount) {

tot_nargs += new_nargs - pto_phcount;

}

PyObject *item;

PyObject *tot_args = PyTuple_New(tot_nargs);

if (tot_args == NULL) {

Py_DECREF(new_args);

Py_DECREF(pto);

return NULL;

}

for (Py_ssize_t i = 0, j = 0; i < tot_nargs; i++) {

if (i < npargs) {

item = PyTuple_GET_ITEM(pto_args, i);

if (j < new_nargs && item == phold) {

item = PyTuple_GET_ITEM(new_args, j);

j++;

pto_phcount--;

}

}

else {

item = PyTuple_GET_ITEM(new_args, j);

j++;

}

Py_INCREF(item);

PyTuple_SET_ITEM(tot_args, i, item);

}

pto->args = tot_args;

pto->phcount = pto_phcount + phcount;

Py_DECREF(new_args);

}

else if (pto_args == NULL) {

pto->args = new_args;

pto->phcount = phcount;

}

else {

pto->args = PySequence_Concat(pto_args, new_args);

pto->phcount = pto_phcount + phcount;

Py_DECREF(new_args);

if (pto->args == NULL) {

Py_DECREF(pto);

return NULL;

}

assert(PyTuple_Check(pto->args));

}

if (pto_kw == NULL || PyDict_GET_SIZE(pto_kw) == 0) {

if (kw == NULL) {

pto->kw = PyDict_New();

}

else if (_PyObject_IsUniquelyReferenced(kw)) {

pto->kw = Py_NewRef(kw);

}

else {

pto->kw = PyDict_Copy(kw);

}

}

else {

pto->kw = PyDict_Copy(pto_kw);

if (kw != NULL && pto->kw != NULL) {

if (PyDict_Merge(pto->kw, kw, 1) != 0) {

Py_DECREF(pto);

return NULL;

}

}

}

if (pto->kw == NULL) {

Py_DECREF(pto);

return NULL;

}

partial_setvectorcall(pto);

return (PyObject *)pto;

}

static int

partial_clear(PyObject *self)

{

partialobject *pto = partialobject_CAST(self);

Py_CLEAR(pto->fn);

Py_CLEAR(pto->args);

Py_CLEAR(pto->kw);

Py_CLEAR(pto->dict);

return 0;

}

static int

partial_traverse(PyObject *self, visitproc visit, void *arg)

{

partialobject *pto = partialobject_CAST(self);

Py_VISIT(Py_TYPE(pto));

Py_VISIT(pto->fn);

Py_VISIT(pto->args);

Py_VISIT(pto->kw);

Py_VISIT(pto->dict);

return 0;

}

static void

partial_dealloc(PyObject *self)

{

PyTypeObject *tp = Py_TYPE(self);

/* bpo-31095: UnTrack is needed before calling any callbacks */

PyObject_GC_UnTrack(self);

FT_CLEAR_WEAKREFS(self, partialobject_CAST(self)->weakreflist);

(void)partial_clear(self);

tp->tp_free(self);

Py_DECREF(tp);

}

static PyObject *

partial_descr_get(PyObject *self, PyObject *obj, PyObject *type)

{

if (obj == Py_None || obj == NULL) {

return Py_NewRef(self);

}

return PyMethod_New(self, obj);

}

static PyObject *

partial_vectorcall(PyObject *self, PyObject *const *args,

size_t nargsf, PyObject *kwnames)

{

partialobject *pto = partialobject_CAST(self);;

PyThreadState *tstate = _PyThreadState_GET();

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

/* Placeholder check */

Py_ssize_t pto_phcount = pto->phcount;

if (nargs < pto_phcount) {

PyErr_Format(PyExc_TypeError,

"missing positional arguments in 'partial' call; "

"expected at least %zd, got %zd", pto_phcount, nargs);

return NULL;

}

PyObject *result = NULL;

PyObject *partial_function = Py_NewRef(pto->fn);

PyObject *partial_args = Py_NewRef(pto->args);

PyObject *partial_keywords = Py_NewRef(pto->kw);

PyObject **pto_args = _PyTuple_ITEMS(partial_args);

Py_ssize_t pto_nargs = PyTuple_GET_SIZE(partial_args);

Py_ssize_t pto_nkwds = PyDict_GET_SIZE(partial_keywords);

Py_ssize_t nkwds = kwnames == NULL ? 0 : PyTuple_GET_SIZE(kwnames);

Py_ssize_t nargskw = nargs + nkwds;

/* Special cases */

if (!pto_nkwds) {

/* Fast path if we're called without arguments */

if (nargskw == 0) {

result = _PyObject_VectorcallTstate(tstate, partial_function, pto_args,

pto_nargs, NULL);

goto done;

}

/* Use PY_VECTORCALL_ARGUMENTS_OFFSET to prepend a single

if (pto_nargs == 1 && (nargsf & PY_VECTORCALL_ARGUMENTS_OFFSET)) {

PyObject **newargs = (PyObject **)args - 1;

PyObject *tmp = newargs[0];

newargs[0] = pto_args[0];

result = _PyObject_VectorcallTstate(tstate, partial_function, newargs,

nargs + 1, kwnames);

newargs[0] = tmp;

goto done;

}

}

/* Total sizes */

Py_ssize_t tot_nargs = pto_nargs + nargs - pto_phcount;

Py_ssize_t tot_nkwds = pto_nkwds + nkwds;

Py_ssize_t tot_nargskw = tot_nargs + tot_nkwds;

PyObject *pto_kw_merged = NULL; // pto_kw with duplicates merged (if any)

PyObject *tot_kwnames;

/* Allocate Stack

PyObject *small_stack[_PY_FASTCALL_SMALL_STACK * 2];

PyObject **tmp_stack, **stack;

Py_ssize_t init_stack_size = tot_nargskw;

if (pto_nkwds) {

// If pto_nkwds, allocate additional space for temporary new keys

init_stack_size += nkwds;

}

if (init_stack_size <= (Py_ssize_t)Py_ARRAY_LENGTH(small_stack)) {

stack = small_stack;

}

else {

stack = PyMem_Malloc(init_stack_size * sizeof(PyObject *));

if (stack == NULL) {

PyErr_NoMemory();

goto done;

}

}

/* Copy keywords to stack */

if (!pto_nkwds) {

tot_kwnames = kwnames;

if (nkwds) {

/* if !pto_nkwds & nkwds, then simply append kw */

memcpy(stack + tot_nargs, args + nargs, nkwds * sizeof(PyObject*));

}

}

else {

/* stack is now [<positionals>, <pto_kwds>, <kwds>, <kwds_keys>]

PyObject *key, *val;

/* Merge kw to pto_kw or add to tail (if not duplicate) */

Py_ssize_t n_tail = 0;

for (Py_ssize_t i = 0; i < nkwds; ++i) {

key = PyTuple_GET_ITEM(kwnames, i);

val = args[nargs + i];

int contains = PyDict_Contains(partial_keywords, key);

if (contains < 0) {

goto clean_stack;

}

else if (contains == 1) {

if (pto_kw_merged == NULL) {

pto_kw_merged = PyDict_Copy(partial_keywords);

if (pto_kw_merged == NULL) {

goto clean_stack;

}

}

if (PyDict_SetItem(pto_kw_merged, key, val) < 0) {

Py_DECREF(pto_kw_merged);

goto clean_stack;

}

}

else {

/* Copy keyword tail to stack */

stack[tot_nargs + pto_nkwds + n_tail] = val;

stack[tot_nargskw + n_tail] = key;

n_tail++;

}

}

Py_ssize_t n_merges = nkwds - n_tail;

/* Create total kwnames */

tot_kwnames = PyTuple_New(tot_nkwds - n_merges);

if (tot_kwnames == NULL) {

Py_XDECREF(pto_kw_merged);

goto clean_stack;

}

for (Py_ssize_t i = 0; i < n_tail; ++i) {

key = Py_NewRef(stack[tot_nargskw + i]);

PyTuple_SET_ITEM(tot_kwnames, pto_nkwds + i, key);

}

/* Copy pto_keywords with overlapping call keywords merged

Py_ssize_t pos = 0, i = 0;

PyObject *keyword_dict = n_merges ? pto_kw_merged : partial_keywords;

Py_BEGIN_CRITICAL_SECTION(keyword_dict);

while (PyDict_Next(keyword_dict, &pos, &key, &val)) {

assert(i < pto_nkwds);

PyTuple_SET_ITEM(tot_kwnames, i, Py_NewRef(key));

stack[tot_nargs + i] = val;

i++;

}

Py_END_CRITICAL_SECTION();

assert(i == pto_nkwds);

Py_XDECREF(pto_kw_merged);

/* Resize Stack if the removing overallocation saves some noticable memory

Py_ssize_t noveralloc = n_merges + nkwds;

if (stack != small_stack && noveralloc > 6 && noveralloc > init_stack_size / 10) {

tmp_stack = PyMem_Realloc(stack, (tot_nargskw - n_merges) * sizeof(PyObject *));

if (tmp_stack == NULL) {

Py_DECREF(tot_kwnames);

PyErr_NoMemory();

goto clean_stack;

}

stack = tmp_stack;

}

}

/* Copy Positionals to stack */

if (pto_phcount) {

Py_ssize_t j = 0; // New args index

for (Py_ssize_t i = 0; i < pto_nargs; i++) {

if (pto_args[i] == pto->placeholder) {

stack[i] = args[j];

j += 1;

}

else {

stack[i] = pto_args[i];

}

}

assert(j == pto_phcount);

/* Add remaining args from new_args */

if (nargs > pto_phcount) {

memcpy(stack + pto_nargs, args + j, (nargs - j) * sizeof(PyObject*));

}

}

else {

memcpy(stack, pto_args, pto_nargs * sizeof(PyObject*));

memcpy(stack + pto_nargs, args, nargs * sizeof(PyObject*));

}

result = _PyObject_VectorcallTstate(tstate, partial_function, stack,

tot_nargs, tot_kwnames);

if (pto_nkwds) {

Py_DECREF(tot_kwnames);

}

clean_stack:

if (stack != small_stack) {

PyMem_Free(stack);

}

done:

Py_DECREF(partial_function);

Py_DECREF(partial_args);

Py_DECREF(partial_keywords);

return result;

}

static void

partial_setvectorcall(partialobject *pto)

{

if (PyVectorcall_Function(pto->fn) == NULL) {

/* Don't use vectorcall if the underlying function doesn't support it */

pto->vectorcall = NULL;

}

/* We could have a special case if there are no arguments,

else {

pto->vectorcall = partial_vectorcall;

}

}

static PyObject *

partial_call(PyObject *self, PyObject *args, PyObject *kwargs)

{

partialobject *pto = partialobject_CAST(self);

assert(PyCallable_Check(pto->fn));

assert(PyTuple_Check(pto->args));

assert(PyDict_Check(pto->kw));

Py_ssize_t nargs = PyTuple_GET_SIZE(args);

Py_ssize_t pto_phcount = pto->phcount;

if (nargs < pto_phcount) {

PyErr_Format(PyExc_TypeError,

"missing positional arguments in 'partial' call; "

"expected at least %zd, got %zd", pto_phcount, nargs);

return NULL;

}

/* Merge keywords */

PyObject *tot_kw;

if (PyDict_GET_SIZE(pto->kw) == 0) {

/* kwargs can be NULL */

tot_kw = Py_XNewRef(kwargs);

}

else {

/* bpo-27840, bpo-29318: dictionary of keyword parameters must be

tot_kw = PyDict_Copy(pto->kw);

if (tot_kw == NULL) {

return NULL;

}

if (kwargs != NULL) {

if (PyDict_Merge(tot_kw, kwargs, 1) != 0) {

Py_DECREF(tot_kw);

return NULL;

}

}

}

/* Merge positional arguments */

PyObject *tot_args;

if (pto_phcount) {

Py_ssize_t pto_nargs = PyTuple_GET_SIZE(pto->args);

Py_ssize_t tot_nargs = pto_nargs + nargs - pto_phcount;

assert(tot_nargs >= 0);

tot_args = PyTuple_New(tot_nargs);

if (tot_args == NULL) {

Py_XDECREF(tot_kw);

return NULL;

}

PyObject *pto_args = pto->args;

PyObject *item;

Py_ssize_t j = 0; // New args index

for (Py_ssize_t i = 0; i < pto_nargs; i++) {

item = PyTuple_GET_ITEM(pto_args, i);

if (item == pto->placeholder) {

item = PyTuple_GET_ITEM(args, j);

j += 1;

}

Py_INCREF(item);

PyTuple_SET_ITEM(tot_args, i, item);

}

assert(j == pto_phcount);

for (Py_ssize_t i = pto_nargs; i < tot_nargs; i++) {

item = PyTuple_GET_ITEM(args, j);

Py_INCREF(item);

PyTuple_SET_ITEM(tot_args, i, item);

j += 1;

}

}

else {

/* Note: tupleconcat() is optimized for empty tuples */

tot_args = PySequence_Concat(pto->args, args);

if (tot_args == NULL) {

Py_XDECREF(tot_kw);

return NULL;

}

}

PyObject *res = PyObject_Call(pto->fn, tot_args, tot_kw);

Py_DECREF(tot_args);

Py_XDECREF(tot_kw);

return res;

}

PyDoc_STRVAR(partial_doc,

and keywords.");

#define OFF(x) offsetof(partialobject, x)

static PyMemberDef partial_memberlist[] = {

{"func", _Py_T_OBJECT, OFF(fn), Py_READONLY,

"function object to use in future partial calls"},

{"args", _Py_T_OBJECT, OFF(args), Py_READONLY,

"tuple of arguments to future partial calls"},

{"keywords", _Py_T_OBJECT, OFF(kw), Py_READONLY,

"dictionary of keyword arguments to future partial calls"},

{"__weaklistoffset__", Py_T_PYSSIZET,

offsetof(partialobject, weakreflist), Py_READONLY},

{"__dictoffset__", Py_T_PYSSIZET,

offsetof(partialobject, dict), Py_READONLY},

{"__vectorcalloffset__", Py_T_PYSSIZET,

offsetof(partialobject, vectorcall), Py_READONLY},

{NULL} /* Sentinel */

};

static PyGetSetDef partial_getsetlist[] = {

{"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},

{NULL} /* Sentinel */

};

static PyObject *

partial_repr(PyObject *self)

{

partialobject *pto = partialobject_CAST(self);

PyObject *result = NULL;

PyObject *arglist = NULL;

PyObject *mod = NULL;

PyObject *name = NULL;

Py_ssize_t i, n;

PyObject *key, *value;

int status;

status = Py_ReprEnter(self);

if (status != 0) {

if (status < 0) {

return NULL;

}

return PyUnicode_FromString("...");

}

/* Reference arguments in case they change */

PyObject *fn = Py_NewRef(pto->fn);

PyObject *args = Py_NewRef(pto->args);

PyObject *kw = Py_NewRef(pto->kw);

assert(PyTuple_Check(args));

assert(PyDict_Check(kw));

arglist = Py_GetConstant(Py_CONSTANT_EMPTY_STR);

if (arglist == NULL) {

goto done;

}

/* Pack positional arguments */

n = PyTuple_GET_SIZE(args);

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

Py_SETREF(arglist, PyUnicode_FromFormat("%U, %R", arglist,

PyTuple_GET_ITEM(args, i)));

if (arglist == NULL) {

goto done;

}

}

/* Pack keyword arguments */

int error = 0;

Py_BEGIN_CRITICAL_SECTION(kw);

for (i = 0; PyDict_Next(kw, &i, &key, &value);) {

/* Prevent key.__str__ from deleting the value. */

Py_INCREF(value);

Py_SETREF(arglist, PyUnicode_FromFormat("%U, %S=%R", arglist,

key, value));

Py_DECREF(value);

if (arglist == NULL) {

error = 1;

break;

}

}

Py_END_CRITICAL_SECTION();

if (error) {

goto done;

}

mod = PyType_GetModuleName(Py_TYPE(pto));

if (mod == NULL) {

goto done;

}

name = PyType_GetQualName(Py_TYPE(pto));

if (name == NULL) {

goto done;

}

result = PyUnicode_FromFormat("%S.%S(%R%U)", mod, name, fn, arglist);

done:

Py_XDECREF(name);

Py_XDECREF(mod);

Py_XDECREF(arglist);

Py_DECREF(fn);

Py_DECREF(args);

Py_DECREF(kw);

Py_ReprLeave(self);

return result;

}

static PyObject *

partial_reduce(PyObject *self, PyObject *Py_UNUSED(args))

{

partialobject *pto = partialobject_CAST(self);

return Py_BuildValue("O(O)(OOOO)", Py_TYPE(pto), pto->fn, pto->fn,

pto->args, pto->kw,

pto->dict ? pto->dict : Py_None);

}

static PyObject *

partial_setstate(PyObject *self, PyObject *state)

{

partialobject *pto = partialobject_CAST(self);

PyObject *fn, *fnargs, *kw, *dict;

if (!PyTuple_Check(state)) {

PyErr_SetString(PyExc_TypeError, "invalid partial state");

return NULL;

}

if (!PyArg_ParseTuple(state, "OOOO", &fn, &fnargs, &kw, &dict) ||

!PyCallable_Check(fn) ||

!PyTuple_Check(fnargs) ||

(kw != Py_None && !PyDict_Check(kw)) ||

(dict != Py_None && !PyDict_Check(dict)))

{

PyErr_SetString(PyExc_TypeError, "invalid partial state");

return NULL;

}

Py_ssize_t nargs = PyTuple_GET_SIZE(fnargs);

if (nargs && PyTuple_GET_ITEM(fnargs, nargs - 1) == pto->placeholder) {

PyErr_SetString(PyExc_TypeError,

"trailing Placeholders are not allowed");

return NULL;

}

/* Count placeholders */

Py_ssize_t phcount = 0;

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

if (PyTuple_GET_ITEM(fnargs, i) == pto->placeholder) {

phcount++;

}

}

if(!PyTuple_CheckExact(fnargs))

fnargs = PySequence_Tuple(fnargs);

else

Py_INCREF(fnargs);

if (fnargs == NULL)

return NULL;

if (kw == Py_None)

kw = PyDict_New();

else if(!PyDict_CheckExact(kw))

kw = PyDict_Copy(kw);

else

Py_INCREF(kw);

if (kw == NULL) {

Py_DECREF(fnargs);

return NULL;

}

if (dict == Py_None)

dict = NULL;

else

Py_INCREF(dict);

Py_SETREF(pto->fn, Py_NewRef(fn));

Py_SETREF(pto->args, fnargs);

Py_SETREF(pto->kw, kw);

pto->phcount = phcount;

Py_XSETREF(pto->dict, dict);

partial_setvectorcall(pto);

Py_RETURN_NONE;

}

static PyMethodDef partial_methods[] = {

{"__reduce__", partial_reduce, METH_NOARGS},

{"__setstate__", partial_setstate, METH_O},

{"__class_getitem__", Py_GenericAlias,

METH_O|METH_CLASS,

PyDoc_STR("partial is generic over the wrapped function's return type")},

{NULL, NULL} /* sentinel */

};

static PyType_Slot partial_type_slots[] = {

{Py_tp_dealloc, partial_dealloc},

{Py_tp_repr, partial_repr},

{Py_tp_call, partial_call},

{Py_tp_getattro, PyObject_GenericGetAttr},

{Py_tp_setattro, PyObject_GenericSetAttr},

{Py_tp_doc, (void *)partial_doc},

{Py_tp_traverse, partial_traverse},

{Py_tp_clear, partial_clear},

{Py_tp_methods, partial_methods},

{Py_tp_members, partial_memberlist},

{Py_tp_getset, partial_getsetlist},

{Py_tp_descr_get, partial_descr_get},

{Py_tp_new, partial_new},

{Py_tp_free, PyObject_GC_Del},

{0, 0}

};

static PyType_Spec partial_type_spec = {

.name = "functools.partial",

.basicsize = sizeof(partialobject),

.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |

Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_VECTORCALL |

Py_TPFLAGS_IMMUTABLETYPE,

.slots = partial_type_slots

};

typedef struct {

PyObject_HEAD

PyObject *cmp;

PyObject *object;

} keyobject;

#define keyobject_CAST(op) ((keyobject *)(op))

static int

keyobject_clear(PyObject *op)

{

keyobject *ko = keyobject_CAST(op);

Py_CLEAR(ko->cmp);

Py_CLEAR(ko->object);

return 0;

}

static void

keyobject_dealloc(PyObject *ko)

{

PyTypeObject *tp = Py_TYPE(ko);

PyObject_GC_UnTrack(ko);

(void)keyobject_clear(ko);

tp->tp_free(ko);

Py_DECREF(tp);

}

static int

keyobject_traverse(PyObject *op, visitproc visit, void *arg)

{

keyobject *ko = keyobject_CAST(op);

Py_VISIT(Py_TYPE(ko));

Py_VISIT(ko->cmp);

Py_VISIT(ko->object);

return 0;

}

static PyMemberDef keyobject_members[] = {

{"obj", _Py_T_OBJECT,

offsetof(keyobject, object), 0,

PyDoc_STR("Value wrapped by a key function.")},

{NULL}

};

static PyObject *

keyobject_text_signature(PyObject *Py_UNUSED(self), void *Py_UNUSED(ignored))

{

return PyUnicode_FromString("(obj)");

}

static PyGetSetDef keyobject_getset[] = {

{"__text_signature__", keyobject_text_signature, NULL},

{NULL}

};

static PyObject *

keyobject_call(PyObject *ko, PyObject *args, PyObject *kwds);

static PyObject *

keyobject_richcompare(PyObject *ko, PyObject *other, int op);

static PyType_Slot keyobject_type_slots[] = {

{Py_tp_dealloc, keyobject_dealloc},

{Py_tp_call, keyobject_call},

{Py_tp_getattro, PyObject_GenericGetAttr},

{Py_tp_traverse, keyobject_traverse},

{Py_tp_clear, keyobject_clear},

{Py_tp_richcompare, keyobject_richcompare},

{Py_tp_members, keyobject_members},

{Py_tp_getset, keyobject_getset},

{0, 0}

};

static PyType_Spec keyobject_type_spec = {

.name = "functools.KeyWrapper",

.basicsize = sizeof(keyobject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |

Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),

.slots = keyobject_type_slots

};

static PyObject *

keyobject_call(PyObject *self, PyObject *args, PyObject *kwds)

{

PyObject *object;

keyobject *result;

static char *kwargs[] = {"obj", NULL};

keyobject *ko = keyobject_CAST(self);

if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:K", kwargs, &object))

return NULL;

result = PyObject_GC_New(keyobject, Py_TYPE(ko));

if (result == NULL) {

return NULL;

}

result->cmp = Py_NewRef(ko->cmp);

result->object = Py_NewRef(object);

PyObject_GC_Track(result);

return (PyObject *)result;

}

static PyObject *

keyobject_richcompare(PyObject *self, PyObject *other, int op)

{

if (!Py_IS_TYPE(other, Py_TYPE(self))) {

PyErr_Format(PyExc_TypeError, "other argument must be K instance");

return NULL;

}

keyobject *lhs = keyobject_CAST(self);

keyobject *rhs = keyobject_CAST(other);

PyObject *compare = lhs->cmp;

assert(compare != NULL);

PyObject *x = lhs->object;

PyObject *y = rhs->object;

if (!x || !y){

PyErr_Format(PyExc_AttributeError, "object");

return NULL;

}

/* Call the user's comparison function and translate the 3-way

PyObject* args[2] = {x, y};

PyObject *res = PyObject_Vectorcall(compare, args, 2, NULL);

if (res == NULL) {

return NULL;

}

PyObject *answer = PyObject_RichCompare(res, _PyLong_GetZero(), op);

Py_DECREF(res);

return answer;

}

static PyObject *

_functools_cmp_to_key_impl(PyObject *module, PyObject *mycmp)

{

keyobject *object;

_functools_state *state;

state = get_functools_state(module);

object = PyObject_GC_New(keyobject, state->keyobject_type);

if (!object)

return NULL;

object->cmp = Py_NewRef(mycmp);

object->object = NULL;

PyObject_GC_Track(object);

return (PyObject *)object;

}