cpython/Modules/_abc.c

/* ABCMeta implementation */
#ifndef Py_BUILD_CORE_BUILTIN
#define Py_BUILD_CORE_MODULE …
#endif

#include "Python.h"
#include "pycore_moduleobject.h"  // _PyModule_GetState()
#include "pycore_object.h"        // _PyType_GetSubclasses()
#include "pycore_runtime.h"       // _Py_ID()
#include "pycore_setobject.h"     // _PySet_NextEntry()
#include "pycore_weakref.h"       // _PyWeakref_GET_REF()
#include "clinic/_abc.c.h"

/*[clinic input]
module _abc
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=964f5328e1aefcda]*/

PyDoc_STRVAR(_abc__doc__,
"Module contains faster C implementation of abc.ABCMeta");

_abcmodule_state;

static inline _abcmodule_state*
get_abc_state(PyObject *module)
{ … }

static inline uint64_t
get_invalidation_counter(_abcmodule_state *state)
{ … }

static inline void
increment_invalidation_counter(_abcmodule_state *state)
{ … }

/* This object stores internal state for ABCs.
   Note that we can use normal sets for caches,
   since they are never iterated over. */
_abc_data;

static inline uint64_t
get_cache_version(_abc_data *impl)
{ … }

static inline void
set_cache_version(_abc_data *impl, uint64_t version)
{ … }

static int
abc_data_traverse(_abc_data *self, visitproc visit, void *arg)
{ … }

static int
abc_data_clear(_abc_data *self)
{ … }

static void
abc_data_dealloc(_abc_data *self)
{ … }

static PyObject *
abc_data_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{ … }

PyDoc_STRVAR(abc_data_doc,
"Internal state held by ABC machinery.");

static PyType_Slot _abc_data_type_spec_slots[] = …;

static PyType_Spec _abc_data_type_spec = …;

static _abc_data *
_get_impl(PyObject *module, PyObject *self)
{ … }

static int
_in_weak_set(_abc_data *impl, PyObject **pset, PyObject *obj)
{ … }

static PyObject *
_destroy(PyObject *setweakref, PyObject *objweakref)
{ … }

static PyMethodDef _destroy_def = …;

static int
_add_to_weak_set(_abc_data *impl, PyObject **pset, PyObject *obj)
{ … }

/*[clinic input]
_abc._reset_registry

    self: object
    /

Internal ABC helper to reset registry of a given class.

Should be only used by refleak.py
[clinic start generated code]*/

static PyObject *
_abc__reset_registry(PyObject *module, PyObject *self)
/*[clinic end generated code: output=92d591a43566cc10 input=12a0b7eb339ac35c]*/
{ … }

/*[clinic input]
_abc._reset_caches

    self: object
    /

Internal ABC helper to reset both caches of a given class.

Should be only used by refleak.py
[clinic start generated code]*/

static PyObject *
_abc__reset_caches(PyObject *module, PyObject *self)
/*[clinic end generated code: output=f296f0d5c513f80c input=c0ac616fd8acfb6f]*/
{ … }

/*[clinic input]
_abc._get_dump

    self: object
    /

Internal ABC helper for cache and registry debugging.

Return shallow copies of registry, of both caches, and
negative cache version. Don't call this function directly,
instead use ABC._dump_registry() for a nice repr.
[clinic start generated code]*/

static PyObject *
_abc__get_dump(PyObject *module, PyObject *self)
/*[clinic end generated code: output=9d9569a8e2c1c443 input=2c5deb1bfe9e3c79]*/
{ … }

// Compute set of abstract method names.
static int
compute_abstract_methods(PyObject *self)
{ … }

#define COLLECTION_FLAGS …

/*[clinic input]
_abc._abc_init

    self: object
    /

Internal ABC helper for class set-up. Should be never used outside abc module.
[clinic start generated code]*/

static PyObject *
_abc__abc_init(PyObject *module, PyObject *self)
/*[clinic end generated code: output=594757375714cda1 input=8d7fe470ff77f029]*/
{ … }

/*[clinic input]
_abc._abc_register

    self: object
    subclass: object
    /

Internal ABC helper for subclasss registration. Should be never used outside abc module.
[clinic start generated code]*/

static PyObject *
_abc__abc_register_impl(PyObject *module, PyObject *self, PyObject *subclass)
/*[clinic end generated code: output=7851e7668c963524 input=ca589f8c3080e67f]*/
{ … }


/*[clinic input]
_abc._abc_instancecheck

    self: object
    instance: object
    /

Internal ABC helper for instance checks. Should be never used outside abc module.
[clinic start generated code]*/

static PyObject *
_abc__abc_instancecheck_impl(PyObject *module, PyObject *self,
                             PyObject *instance)
/*[clinic end generated code: output=b8b5148f63b6b56f input=a4f4525679261084]*/
{ … }


// Return -1 when exception occurred.
// Return 1 when result is set.
// Return 0 otherwise.
static int subclasscheck_check_registry(_abc_data *impl, PyObject *subclass,
                                        PyObject **result);

/*[clinic input]
_abc._abc_subclasscheck

    self: object
    subclass: object
    /

Internal ABC helper for subclasss checks. Should be never used outside abc module.
[clinic start generated code]*/

static PyObject *
_abc__abc_subclasscheck_impl(PyObject *module, PyObject *self,
                             PyObject *subclass)
/*[clinic end generated code: output=b56c9e4a530e3894 input=1d947243409d10b8]*/
{ … }


static int
subclasscheck_check_registry(_abc_data *impl, PyObject *subclass,
                             PyObject **result)
{ … }

/*[clinic input]
_abc.get_cache_token

Returns the current ABC cache token.

The token is an opaque object (supporting equality testing) identifying the
current version of the ABC cache for virtual subclasses. The token changes
with every call to register() on any ABC.
[clinic start generated code]*/

static PyObject *
_abc_get_cache_token_impl(PyObject *module)
/*[clinic end generated code: output=c7d87841e033dacc input=70413d1c423ad9f9]*/
{ … }

static struct PyMethodDef _abcmodule_methods[] = …;

static int
_abcmodule_exec(PyObject *module)
{ … }

static int
_abcmodule_traverse(PyObject *module, visitproc visit, void *arg)
{ … }

static int
_abcmodule_clear(PyObject *module)
{ … }

static void
_abcmodule_free(void *module)
{ … }

static PyModuleDef_Slot _abcmodule_slots[] = …;

static struct PyModuleDef _abcmodule = …;

PyMODINIT_FUNC
PyInit__abc(void)
{ … }