#include "Python.h"

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

#include "pycore_modsupport.h" // _PyArg_NoKeywords()

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

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

static const char *

func_event_name(PyFunction_WatchEvent event) {

switch (event) {

#define CASE(op) \

case PyFunction_EVENT_##op: \

return "PyFunction_EVENT_" #op;

PY_FOREACH_FUNC_EVENT(CASE)

#undef CASE

}

Py_UNREACHABLE();

}

static void

notify_func_watchers(PyInterpreterState *interp, PyFunction_WatchEvent event,

PyFunctionObject *func, PyObject *new_value)

{

uint8_t bits = interp->active_func_watchers;

int i = 0;

while (bits) {

assert(i < FUNC_MAX_WATCHERS);

if (bits & 1) {

PyFunction_WatchCallback cb = interp->func_watchers[i];

// callback must be non-null if the watcher bit is set

assert(cb != NULL);

if (cb(event, func, new_value) < 0) {

PyErr_FormatUnraisable(

"Exception ignored in %s watcher callback for function %U at %p",

func_event_name(event), func->func_qualname, func);

}

}

i++;

bits >>= 1;

}

}

static inline void

handle_func_event(PyFunction_WatchEvent event, PyFunctionObject *func,

PyObject *new_value)

{

assert(Py_REFCNT(func) > 0);

PyInterpreterState *interp = _PyInterpreterState_GET();

assert(interp->_initialized);

if (interp->active_func_watchers) {

notify_func_watchers(interp, event, func, new_value);

}

switch (event) {

case PyFunction_EVENT_MODIFY_CODE:

case PyFunction_EVENT_MODIFY_DEFAULTS:

case PyFunction_EVENT_MODIFY_KWDEFAULTS:

RARE_EVENT_INTERP_INC(interp, func_modification);

break;

default:

break;

}

}

PyFunction_AddWatcher(PyFunction_WatchCallback callback)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

assert(interp->_initialized);

for (int i = 0; i < FUNC_MAX_WATCHERS; i++) {

if (interp->func_watchers[i] == NULL) {

interp->func_watchers[i] = callback;

interp->active_func_watchers |= (1 << i);

return i;

}

}

PyErr_SetString(PyExc_RuntimeError, "no more func watcher IDs available");

return -1;

}

PyFunction_ClearWatcher(int watcher_id)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

if (watcher_id < 0 || watcher_id >= FUNC_MAX_WATCHERS) {

PyErr_Format(PyExc_ValueError, "invalid func watcher ID %d",

watcher_id);

return -1;

}

if (!interp->func_watchers[watcher_id]) {

PyErr_Format(PyExc_ValueError, "no func watcher set for ID %d",

watcher_id);

return -1;

}

interp->func_watchers[watcher_id] = NULL;

interp->active_func_watchers &= ~(1 << watcher_id);

return 0;

}

PyFunctionObject *

_PyFunction_FromConstructor(PyFrameConstructor *constr)

{

PyObject *module;

if (PyDict_GetItemRef(constr->fc_globals, &_Py_ID(__name__), &module) < 0) {

return NULL;

}

PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type);

if (op == NULL) {

Py_XDECREF(module);

return NULL;

}

op->func_globals = Py_NewRef(constr->fc_globals);

op->func_builtins = Py_NewRef(constr->fc_builtins);

op->func_name = Py_NewRef(constr->fc_name);

op->func_qualname = Py_NewRef(constr->fc_qualname);

op->func_code = Py_NewRef(constr->fc_code);

op->func_defaults = Py_XNewRef(constr->fc_defaults);

op->func_kwdefaults = Py_XNewRef(constr->fc_kwdefaults);

op->func_closure = Py_XNewRef(constr->fc_closure);

op->func_doc = Py_NewRef(Py_None);

op->func_dict = NULL;

op->func_weakreflist = NULL;

op->func_module = module;

op->func_annotations = NULL;

op->func_typeparams = NULL;

op->vectorcall = _PyFunction_Vectorcall;

op->func_version = 0;

// NOTE: functions created via FrameConstructor do not use deferred

// reference counting because they are typically not part of cycles

// nor accessed by multiple threads.

_PyObject_GC_TRACK(op);

handle_func_event(PyFunction_EVENT_CREATE, op, NULL);

return op;

}

PyObject *

PyFunction_NewWithQualName(PyObject *code, PyObject *globals, PyObject *qualname)

{

assert(globals != NULL);

assert(PyDict_Check(globals));

Py_INCREF(globals);

PyThreadState *tstate = _PyThreadState_GET();

PyCodeObject *code_obj = (PyCodeObject *)Py_NewRef(code);

assert(code_obj->co_name != NULL);

PyObject *name = Py_NewRef(code_obj->co_name);

if (!qualname) {

qualname = code_obj->co_qualname;

}

assert(qualname != NULL);

Py_INCREF(qualname);

PyObject *consts = code_obj->co_consts;

assert(PyTuple_Check(consts));

PyObject *doc;

if (PyTuple_Size(consts) >= 1) {

doc = PyTuple_GetItem(consts, 0);

if (!PyUnicode_Check(doc)) {

doc = Py_None;

}

}

else {

doc = Py_None;

}

Py_INCREF(doc);

// __module__: Use globals['__name__'] if it exists, or NULL.

PyObject *module;

PyObject *builtins = NULL;

if (PyDict_GetItemRef(globals, &_Py_ID(__name__), &module) < 0) {

goto error;

}

builtins = _PyEval_BuiltinsFromGlobals(tstate, globals); // borrowed ref

if (builtins == NULL) {

goto error;

}

Py_INCREF(builtins);

PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type);

if (op == NULL) {

goto error;

}

/* Note: No failures from this point on, since func_dealloc() does not

op->func_globals = globals;

op->func_builtins = builtins;

op->func_name = name;

op->func_qualname = qualname;

op->func_code = (PyObject*)code_obj;

op->func_defaults = NULL; // No default positional arguments

op->func_kwdefaults = NULL; // No default keyword arguments

op->func_closure = NULL;

op->func_doc = doc;

op->func_dict = NULL;

op->func_weakreflist = NULL;

op->func_module = module;

op->func_annotations = NULL;

op->func_typeparams = NULL;

op->vectorcall = _PyFunction_Vectorcall;

op->func_version = 0;

if ((code_obj->co_flags & CO_NESTED) == 0) {

// Use deferred reference counting for top-level functions, but not

// nested functions because they are more likely to capture variables,

// which makes prompt deallocation more important.

_PyObject_SetDeferredRefcount((PyObject *)op);

}

_PyObject_GC_TRACK(op);

handle_func_event(PyFunction_EVENT_CREATE, op, NULL);

return (PyObject *)op;

error:

Py_DECREF(globals);

Py_DECREF(code_obj);

Py_DECREF(name);

Py_DECREF(qualname);

Py_DECREF(doc);

Py_XDECREF(module);

Py_XDECREF(builtins);

return NULL;

}

_PyFunction_SetVersion(PyFunctionObject *func, uint32_t version)

{

#ifndef Py_GIL_DISABLED

PyInterpreterState *interp = _PyInterpreterState_GET();

if (func->func_version != 0) {

struct _func_version_cache_item *slot =

interp->func_state.func_version_cache

+ (func->func_version % FUNC_VERSION_CACHE_SIZE);

if (slot->func == func) {

slot->func = NULL;

// Leave slot->code alone, there may be use for it.

}

}

func->func_version = version;

#ifndef Py_GIL_DISABLED

if (version != 0) {

struct _func_version_cache_item *slot =

interp->func_state.func_version_cache

+ (version % FUNC_VERSION_CACHE_SIZE);

slot->func = func;

slot->code = func->func_code;

}

}

_PyFunction_ClearCodeByVersion(uint32_t version)

{

#ifndef Py_GIL_DISABLED

PyInterpreterState *interp = _PyInterpreterState_GET();

struct _func_version_cache_item *slot =

interp->func_state.func_version_cache

+ (version % FUNC_VERSION_CACHE_SIZE);

if (slot->code) {

assert(PyCode_Check(slot->code));

PyCodeObject *code = (PyCodeObject *)slot->code;

if (code->co_version == version) {

slot->code = NULL;

slot->func = NULL;

}

}

}

PyFunctionObject *

_PyFunction_LookupByVersion(uint32_t version, PyObject **p_code)

{

#ifdef Py_GIL_DISABLED

return NULL;

PyInterpreterState *interp = _PyInterpreterState_GET();

struct _func_version_cache_item *slot =

interp->func_state.func_version_cache

+ (version % FUNC_VERSION_CACHE_SIZE);

if (slot->code) {

assert(PyCode_Check(slot->code));

PyCodeObject *code = (PyCodeObject *)slot->code;

if (code->co_version == version) {

*p_code = slot->code;

}

}

else {

*p_code = NULL;

}

if (slot->func && slot->func->func_version == version) {

assert(slot->func->func_code == slot->code);

return slot->func;

}

return NULL;

}

_PyFunction_GetVersionForCurrentState(PyFunctionObject *func)

{

return func->func_version;

}

PyObject *

PyFunction_New(PyObject *code, PyObject *globals)

{

return PyFunction_NewWithQualName(code, globals, NULL);

}

PyObject *

PyFunction_GetCode(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_code;

}

PyObject *

PyFunction_GetGlobals(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_globals;

}

PyObject *

PyFunction_GetModule(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_module;

}

PyObject *

PyFunction_GetDefaults(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_defaults;

}

PyFunction_SetDefaults(PyObject *op, PyObject *defaults)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

if (defaults == Py_None)

defaults = NULL;

else if (defaults && PyTuple_Check(defaults)) {

Py_INCREF(defaults);

}

else {

PyErr_SetString(PyExc_SystemError, "non-tuple default args");

return -1;

}

handle_func_event(PyFunction_EVENT_MODIFY_DEFAULTS,

(PyFunctionObject *) op, defaults);

_PyFunction_SetVersion((PyFunctionObject *)op, 0);

Py_XSETREF(((PyFunctionObject *)op)->func_defaults, defaults);

return 0;

}

PyFunction_SetVectorcall(PyFunctionObject *func, vectorcallfunc vectorcall)

{

assert(func != NULL);

_PyFunction_SetVersion(func, 0);

func->vectorcall = vectorcall;

}

PyObject *

PyFunction_GetKwDefaults(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_kwdefaults;

}

PyFunction_SetKwDefaults(PyObject *op, PyObject *defaults)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

if (defaults == Py_None)

defaults = NULL;

else if (defaults && PyDict_Check(defaults)) {

Py_INCREF(defaults);

}

else {

PyErr_SetString(PyExc_SystemError,

"non-dict keyword only default args");

return -1;

}

handle_func_event(PyFunction_EVENT_MODIFY_KWDEFAULTS,

(PyFunctionObject *) op, defaults);

_PyFunction_SetVersion((PyFunctionObject *)op, 0);

Py_XSETREF(((PyFunctionObject *)op)->func_kwdefaults, defaults);

return 0;

}

PyObject *

PyFunction_GetClosure(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return ((PyFunctionObject *) op) -> func_closure;

}

PyFunction_SetClosure(PyObject *op, PyObject *closure)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

if (closure == Py_None)

closure = NULL;

else if (PyTuple_Check(closure)) {

Py_INCREF(closure);

}

else {

PyErr_Format(PyExc_SystemError,

"expected tuple for closure, got '%.100s'",

Py_TYPE(closure)->tp_name);

return -1;

}

_PyFunction_SetVersion((PyFunctionObject *)op, 0);

Py_XSETREF(((PyFunctionObject *)op)->func_closure, closure);

return 0;

}

static PyObject *

func_get_annotation_dict(PyFunctionObject *op)

{

if (op->func_annotations == NULL) {

return NULL;

}

if (PyTuple_CheckExact(op->func_annotations)) {

PyObject *ann_tuple = op->func_annotations;

PyObject *ann_dict = PyDict_New();

if (ann_dict == NULL) {

return NULL;

}

assert(PyTuple_GET_SIZE(ann_tuple) % 2 == 0);

for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(ann_tuple); i += 2) {

int err = PyDict_SetItem(ann_dict,

PyTuple_GET_ITEM(ann_tuple, i),

PyTuple_GET_ITEM(ann_tuple, i + 1));

if (err < 0) {

return NULL;

}

}

Py_SETREF(op->func_annotations, ann_dict);

}

assert(PyDict_Check(op->func_annotations));

return op->func_annotations;

}

PyObject *

PyFunction_GetAnnotations(PyObject *op)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return NULL;

}

return func_get_annotation_dict((PyFunctionObject *)op);

}

PyFunction_SetAnnotations(PyObject *op, PyObject *annotations)

{

if (!PyFunction_Check(op)) {

PyErr_BadInternalCall();

return -1;

}

if (annotations == Py_None)

annotations = NULL;

else if (annotations && PyDict_Check(annotations)) {

Py_INCREF(annotations);

}

else {

PyErr_SetString(PyExc_SystemError,

"non-dict annotations");

return -1;

}

Py_XSETREF(((PyFunctionObject *)op)->func_annotations, annotations);

return 0;

}

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

static PyMemberDef func_memberlist[] = {

{"__closure__", _Py_T_OBJECT, OFF(func_closure), Py_READONLY},

{"__doc__", _Py_T_OBJECT, OFF(func_doc), 0},

{"__globals__", _Py_T_OBJECT, OFF(func_globals), Py_READONLY},

{"__module__", _Py_T_OBJECT, OFF(func_module), 0},

{"__builtins__", _Py_T_OBJECT, OFF(func_builtins), Py_READONLY},

{NULL} /* Sentinel */

};

static PyObject *

func_get_code(PyFunctionObject *op, void *Py_UNUSED(ignored))

{

if (PySys_Audit("object.__getattr__", "Os", op, "__code__") < 0) {

return NULL;

}

return Py_NewRef(op->func_code);

}

static int

func_set_code(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))

{

Py_ssize_t nclosure;

int nfree;

/* Not legal to del f.func_code or to set it to anything

if (value == NULL || !PyCode_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__code__ must be set to a code object");

return -1;

}

if (PySys_Audit("object.__setattr__", "OsO",

op, "__code__", value) < 0) {

return -1;

}

nfree = ((PyCodeObject *)value)->co_nfreevars;

nclosure = (op->func_closure == NULL ? 0 :

PyTuple_GET_SIZE(op->func_closure));

if (nclosure != nfree) {

PyErr_Format(PyExc_ValueError,

"%U() requires a code object with %zd free vars,"

" not %zd",

op->func_name,

nclosure, nfree);

return -1;

}

PyObject *func_code = PyFunction_GET_CODE(op);

int old_flags = ((PyCodeObject *)func_code)->co_flags;

int new_flags = ((PyCodeObject *)value)->co_flags;

int mask = CO_GENERATOR | CO_COROUTINE | CO_ASYNC_GENERATOR;

if ((old_flags & mask) != (new_flags & mask)) {

if (PyErr_Warn(PyExc_DeprecationWarning,

"Assigning a code object of non-matching type is deprecated "

"(e.g., from a generator to a plain function)") < 0)

{

return -1;

}

}

handle_func_event(PyFunction_EVENT_MODIFY_CODE, op, value);

_PyFunction_SetVersion(op, 0);

Py_XSETREF(op->func_code, Py_NewRef(value));

return 0;

}

static PyObject *

func_get_name(PyFunctionObject *op, void *Py_UNUSED(ignored))

{

return Py_NewRef(op->func_name);

}

static int

func_set_name(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))

{

/* Not legal to del f.func_name or to set it to anything

if (value == NULL || !PyUnicode_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__name__ must be set to a string object");

return -1;

}

Py_XSETREF(op->func_name, Py_NewRef(value));

return 0;

}

static PyObject *

func_get_qualname(PyFunctionObject *op, void *Py_UNUSED(ignored))

{

return Py_NewRef(op->func_qualname);

}

static int

func_set_qualname(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))

{

/* Not legal to del f.__qualname__ or to set it to anything

if (value == NULL || !PyUnicode_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__qualname__ must be set to a string object");

return -1;

}

Py_XSETREF(op->func_qualname, Py_NewRef(value));

return 0;

}

static PyObject *

func_get_defaults(PyFunctionObject *op, void *Py_UNUSED(ignored))

{

if (PySys_Audit("object.__getattr__", "Os", op, "__defaults__") < 0) {

return NULL;

}

if (op->func_defaults == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(op->func_defaults);

}

static int

func_set_defaults(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))

{

/* Legal to del f.func_defaults.

if (value == Py_None)

value = NULL;

if (value != NULL && !PyTuple_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__defaults__ must be set to a tuple object");

return -1;

}

if (value) {

if (PySys_Audit("object.__setattr__", "OsO",

op, "__defaults__", value) < 0) {

return -1;

}

} else if (PySys_Audit("object.__delattr__", "Os",

op, "__defaults__") < 0) {

return -1;

}

handle_func_event(PyFunction_EVENT_MODIFY_DEFAULTS, op, value);

_PyFunction_SetVersion(op, 0);

Py_XSETREF(op->func_defaults, Py_XNewRef(value));

return 0;

}

static PyObject *

func_get_kwdefaults(PyFunctionObject *op, void *Py_UNUSED(ignored))

{

if (PySys_Audit("object.__getattr__", "Os",

op, "__kwdefaults__") < 0) {

return NULL;

}

if (op->func_kwdefaults == NULL) {

Py_RETURN_NONE;

}

return Py_NewRef(op->func_kwdefaults);

}

static int

func_set_kwdefaults(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))

{

if (value == Py_None)

value = NULL;

/* Legal to del f.func_kwdefaults.

if (value != NULL && !PyDict_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__kwdefaults__ must be set to a dict object");

return -1;

}

if (value) {

if (PySys_Audit("object.__setattr__", "OsO",

op, "__kwdefaults__", value) < 0) {

return -1;

}

} else if (PySys_Audit("object.__delattr__", "Os",

op, "__kwdefaults__") < 0) {

return -1;

}

handle_func_event(PyFunction_EVENT_MODIFY_KWDEFAULTS, op, value);

_PyFunction_SetVersion(op, 0);

Py_XSETREF(op->func_kwdefaults, Py_XNewRef(value));

return 0;

}

static PyObject *

func_get_annotations(PyFunctionObject *op, void *Py_UNUSED(ignored))

{

if (op->func_annotations == NULL) {

op->func_annotations = PyDict_New();

if (op->func_annotations == NULL)

return NULL;

}

PyObject *d = func_get_annotation_dict(op);

return Py_XNewRef(d);

}

static int

func_set_annotations(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))

{

if (value == Py_None)

value = NULL;

/* Legal to del f.func_annotations.

if (value != NULL && !PyDict_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__annotations__ must be set to a dict object");

return -1;

}

Py_XSETREF(op->func_annotations, Py_XNewRef(value));

return 0;

}

static PyObject *

func_get_type_params(PyFunctionObject *op, void *Py_UNUSED(ignored))

{

if (op->func_typeparams == NULL) {

return PyTuple_New(0);

}

assert(PyTuple_Check(op->func_typeparams));

return Py_NewRef(op->func_typeparams);

}

static int

func_set_type_params(PyFunctionObject *op, PyObject *value, void *Py_UNUSED(ignored))

{

/* Not legal to del f.__type_params__ or to set it to anything

if (value == NULL || !PyTuple_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"__type_params__ must be set to a tuple");

return -1;

}

Py_XSETREF(op->func_typeparams, Py_NewRef(value));

return 0;

}

PyObject *

_Py_set_function_type_params(PyThreadState *Py_UNUSED(ignored), PyObject *func,

PyObject *type_params)

{

assert(PyFunction_Check(func));

assert(PyTuple_Check(type_params));

PyFunctionObject *f = (PyFunctionObject *)func;

Py_XSETREF(f->func_typeparams, Py_NewRef(type_params));

return Py_NewRef(func);

}

static PyGetSetDef func_getsetlist[] = {

{"__code__", (getter)func_get_code, (setter)func_set_code},

{"__defaults__", (getter)func_get_defaults,

(setter)func_set_defaults},

{"__kwdefaults__", (getter)func_get_kwdefaults,

(setter)func_set_kwdefaults},

{"__annotations__", (getter)func_get_annotations,

(setter)func_set_annotations},

{"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},

{"__name__", (getter)func_get_name, (setter)func_set_name},

{"__qualname__", (getter)func_get_qualname, (setter)func_set_qualname},

{"__type_params__", (getter)func_get_type_params,

(setter)func_set_type_params},

{NULL} /* Sentinel */

};

#include "clinic/funcobject.c.h"

static PyObject *

func_new_impl(PyTypeObject *type, PyCodeObject *code, PyObject *globals,

PyObject *name, PyObject *defaults, PyObject *closure,

PyObject *kwdefaults)

{

PyFunctionObject *newfunc;

Py_ssize_t nclosure;

if (name != Py_None && !PyUnicode_Check(name)) {

PyErr_SetString(PyExc_TypeError,

"arg 3 (name) must be None or string");

return NULL;

}

if (defaults != Py_None && !PyTuple_Check(defaults)) {

PyErr_SetString(PyExc_TypeError,

"arg 4 (defaults) must be None or tuple");

return NULL;

}

if (!PyTuple_Check(closure)) {

if (code->co_nfreevars && closure == Py_None) {

PyErr_SetString(PyExc_TypeError,

"arg 5 (closure) must be tuple");

return NULL;

}

else if (closure != Py_None) {

PyErr_SetString(PyExc_TypeError,

"arg 5 (closure) must be None or tuple");

return NULL;

}

}

if (kwdefaults != Py_None && !PyDict_Check(kwdefaults)) {

PyErr_SetString(PyExc_TypeError,

"arg 6 (kwdefaults) must be None or dict");

return NULL;

}

/* check that the closure is well-formed */

nclosure = closure == Py_None ? 0 : PyTuple_GET_SIZE(closure);

if (code->co_nfreevars != nclosure)

return PyErr_Format(PyExc_ValueError,

"%U requires closure of length %zd, not %zd",

code->co_name, code->co_nfreevars, nclosure);

if (nclosure) {

Py_ssize_t i;

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

PyObject *o = PyTuple_GET_ITEM(closure, i);

if (!PyCell_Check(o)) {

return PyErr_Format(PyExc_TypeError,

"arg 5 (closure) expected cell, found %s",

Py_TYPE(o)->tp_name);

}

}

}

if (PySys_Audit("function.__new__", "O", code) < 0) {

return NULL;

}

newfunc = (PyFunctionObject *)PyFunction_New((PyObject *)code,

globals);

if (newfunc == NULL) {

return NULL;

}

if (name != Py_None) {

Py_SETREF(newfunc->func_name, Py_NewRef(name));

}

if (defaults != Py_None) {

newfunc->func_defaults = Py_NewRef(defaults);

}

if (closure != Py_None) {

newfunc->func_closure = Py_NewRef(closure);

}

if (kwdefaults != Py_None) {

newfunc->func_kwdefaults = Py_NewRef(kwdefaults);

}

return (PyObject *)newfunc;

}

static int

func_clear(PyFunctionObject *op)

{

_PyFunction_SetVersion(op, 0);

Py_CLEAR(op->func_globals);

Py_CLEAR(op->func_builtins);

Py_CLEAR(op->func_module);

Py_CLEAR(op->func_defaults);

Py_CLEAR(op->func_kwdefaults);

Py_CLEAR(op->func_doc);

Py_CLEAR(op->func_dict);

Py_CLEAR(op->func_closure);

Py_CLEAR(op->func_annotations);

Py_CLEAR(op->func_typeparams);

// Don't Py_CLEAR(op->func_code), since code is always required

// to be non-NULL. Similarly, name and qualname shouldn't be NULL.

// However, name and qualname could be str subclasses, so they

// could have reference cycles. The solution is to replace them

// with a genuinely immutable string.

Py_SETREF(op->func_name, &_Py_STR(empty));

Py_SETREF(op->func_qualname, &_Py_STR(empty));

return 0;

}

static void

func_dealloc(PyFunctionObject *op)

{

assert(Py_REFCNT(op) == 0);

Py_SET_REFCNT(op, 1);

handle_func_event(PyFunction_EVENT_DESTROY, op, NULL);

if (Py_REFCNT(op) > 1) {

Py_SET_REFCNT(op, Py_REFCNT(op) - 1);

return;

}

Py_SET_REFCNT(op, 0);

_PyObject_GC_UNTRACK(op);

if (op->func_weakreflist != NULL) {

PyObject_ClearWeakRefs((PyObject *) op);

}