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

PyDoc_STRVAR(placeholder_doc,

"Used as a placeholder for partial arguments.");

static PyObject *

placeholder_repr(PyObject *op)

{

return PyUnicode_FromString("Placeholder");

}

static PyObject *

placeholder_reduce(PyObject *op, PyObject *Py_UNUSED(ignored))

{

return PyUnicode_FromString("Placeholder");

}

static PyMethodDef placeholder_methods[] = {

{"__reduce__", placeholder_reduce, METH_NOARGS, NULL},

{NULL, NULL}

};

static void

placeholder_dealloc(PyObject* self)

{

PyObject_GC_UnTrack(self);

PyTypeObject *tp = Py_TYPE(self);

tp->tp_free((PyObject*)self);

Py_DECREF(tp);

}

static PyObject *

placeholder_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)

{

if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) {

PyErr_SetString(PyExc_TypeError, "PlaceholderType takes no arguments");

return NULL;

}

_functools_state *state = get_functools_state_by_type(type);

if (state->placeholder != NULL) {

return Py_NewRef(state->placeholder);

}

PyObject *placeholder = PyType_GenericNew(type, NULL, NULL);

if (placeholder == NULL) {

return NULL;

}

if (state->placeholder == NULL) {

state->placeholder = Py_NewRef(placeholder);

}

return placeholder;

}

static int

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

{

Py_VISIT(Py_TYPE(self));

return 0;

}

static PyType_Slot placeholder_type_slots[] = {

{Py_tp_dealloc, placeholder_dealloc},

{Py_tp_repr, placeholder_repr},

{Py_tp_doc, (void *)placeholder_doc},

{Py_tp_methods, placeholder_methods},

{Py_tp_new, placeholder_new},

{Py_tp_traverse, placeholder_traverse},

{0, 0}

};

static PyType_Spec placeholder_type_spec = {

.name = "functools._PlaceholderType",

.basicsize = sizeof(placeholderobject),

.flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC,

.slots = placeholder_type_slots

};

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

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

}

Py_NO_INLINE static PyObject *

partial_vectorcall_fallback(PyThreadState *tstate, partialobject *pto,

PyObject *const *args, size_t nargsf,

PyObject *kwnames)

{

pto->vectorcall = NULL;

Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);

return _PyObject_MakeTpCall(tstate, (PyObject *)pto, args, nargs, kwnames);

}

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

/* pto->kw is mutable, so need to check every time */

if (PyDict_GET_SIZE(pto->kw)) {

return partial_vectorcall_fallback(tstate, pto, args, nargsf, kwnames);

}

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;

}

Py_ssize_t nargskw = nargs;

if (kwnames != NULL) {

nargskw += PyTuple_GET_SIZE(kwnames);

}

PyObject **pto_args = _PyTuple_ITEMS(pto->args);

Py_ssize_t pto_nargs = PyTuple_GET_SIZE(pto->args);

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

if (nargskw == 0) {

return _PyObject_VectorcallTstate(tstate, pto->fn,

pto_args, pto_nargs, NULL);

}

/* Fast path using 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];

PyObject *ret = _PyObject_VectorcallTstate(tstate, pto->fn,

newargs, nargs + 1, kwnames);

newargs[0] = tmp;

return ret;

}

PyObject *small_stack[_PY_FASTCALL_SMALL_STACK];

PyObject **stack;

Py_ssize_t tot_nargskw = pto_nargs + nargskw - pto_phcount;

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

stack = small_stack;

}

else {

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

if (stack == NULL) {

PyErr_NoMemory();

return NULL;

}

}

Py_ssize_t tot_nargs;

if (pto_phcount) {

tot_nargs = pto_nargs + nargs - 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);

if (nargskw > pto_phcount) {

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

}

}

else {

tot_nargs = pto_nargs + nargs;

/* Copy to new stack, using borrowed references */

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

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

}

PyObject *ret = _PyObject_VectorcallTstate(tstate, pto->fn,

stack, tot_nargs, kwnames);

if (stack != small_stack) {

PyMem_Free(stack);

}

return ret;

}

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;

PyObject *mod;

PyObject *name;

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

}

arglist = Py_GetConstant(Py_CONSTANT_EMPTY_STR);

if (arglist == NULL)

goto done;

/* Pack positional arguments */

assert(PyTuple_Check(pto->args));

n = PyTuple_GET_SIZE(pto->args);

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

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

PyTuple_GET_ITEM(pto->args, i)));

if (arglist == NULL)

goto done;

}

/* Pack keyword arguments */

assert (PyDict_Check(pto->kw));

for (i = 0; PyDict_Next(pto->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)

goto done;

}

mod = PyType_GetModuleName(Py_TYPE(pto));

if (mod == NULL) {

goto error;

}

name = PyType_GetQualName(Py_TYPE(pto));

if (name == NULL) {

Py_DECREF(mod);

goto error;

}

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

Py_DECREF(mod);

Py_DECREF(name);

Py_DECREF(arglist);

done:

Py_ReprLeave(self);

return result;

error:

Py_DECREF(arglist);

Py_ReprLeave(self);

return NULL;

}

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("See PEP 585")},

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

}

static PyObject *

_functools_reduce_impl(PyObject *module, PyObject *func, PyObject *seq,

PyObject *result)

{

PyObject *args, *it;

if (result != NULL)

Py_INCREF(result);

it = PyObject_GetIter(seq);

if (it == NULL) {

if (PyErr_ExceptionMatches(PyExc_TypeError))

PyErr_SetString(PyExc_TypeError,

"reduce() arg 2 must support iteration");

Py_XDECREF(result);

return NULL;

}

if ((args = PyTuple_New(2)) == NULL)

goto Fail;

for (;;) {

PyObject *op2;

if (!_PyObject_IsUniquelyReferenced(args)) {

Py_DECREF(args);