#include "Python.h"

#include "pycore_call.h"

#include "pycore_code.h" // CO_FAST_FREE

#include "pycore_symtable.h" // _Py_Mangle()

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

#include "pycore_initconfig.h" // _PyStatus_OK()

#include "pycore_memoryobject.h" // _PyMemoryView_FromBufferProc()

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

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

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

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

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

#include "pycore_typeobject.h" // struct type_cache

#include "pycore_unionobject.h" // _Py_union_type_or

#include "pycore_frame.h" // _PyInterpreterFrame

#include "opcode.h" // MAKE_CELL

#include "structmember.h" // PyMemberDef

#include <ctype.h>

#include <stddef.h> // ptrdiff_t

#include "clinic/typeobject.c.h"

#define MCACHE_MAX_ATTR_SIZE 100

#define MCACHE_HASH(version, name_hash) \

(((unsigned int)(version) ^ (unsigned int)(name_hash)) \

& ((1 << MCACHE_SIZE_EXP) - 1))

#define MCACHE_HASH_METHOD(type, name) \

MCACHE_HASH((type)->tp_version_tag, ((Py_ssize_t)(name)) >> 3)

#define MCACHE_CACHEABLE_NAME(name) \

PyUnicode_CheckExact(name) && \

PyUnicode_IS_READY(name) && \

(PyUnicode_GET_LENGTH(name) <= MCACHE_MAX_ATTR_SIZE)

#define NEXT_GLOBAL_VERSION_TAG _PyRuntime.types.next_version_tag

#define NEXT_VERSION_TAG(interp) \

(interp)->types.next_version_tag

typedef struct PySlot_Offset {

short subslot_offset;

short slot_offset;

} PySlot_Offset;

static void

slot_bf_releasebuffer(PyObject *self, Py_buffer *buffer);

static void

releasebuffer_call_python(PyObject *self, Py_buffer *buffer);

static PyObject *

slot_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds);

static PyObject *

lookup_maybe_method(PyObject *self, PyObject *attr, int *unbound);

static int

slot_tp_setattro(PyObject *self, PyObject *name, PyObject *value);

static inline PyTypeObject *

type_from_ref(PyObject *ref)

{

assert(PyWeakref_CheckRef(ref));

PyObject *obj = PyWeakref_GET_OBJECT(ref); // borrowed ref

assert(obj != NULL);

if (obj == Py_None) {

return NULL;

}

assert(PyType_Check(obj));

return _PyType_CAST(obj);

}

static inline int

static_builtin_index_is_set(PyTypeObject *self)

{

return self->tp_subclasses != NULL;

}

static inline size_t

static_builtin_index_get(PyTypeObject *self)

{

assert(static_builtin_index_is_set(self));

/* We store a 1-based index so 0 can mean "not initialized". */

return (size_t)self->tp_subclasses - 1;

}

static inline void

static_builtin_index_set(PyTypeObject *self, size_t index)

{

assert(index < _Py_MAX_STATIC_BUILTIN_TYPES);

/* We store a 1-based index so 0 can mean "not initialized". */

self->tp_subclasses = (PyObject *)(index + 1);

}

static inline void

static_builtin_index_clear(PyTypeObject *self)

{

self->tp_subclasses = NULL;

}

static inline static_builtin_state *

static_builtin_state_get(PyInterpreterState *interp, PyTypeObject *self)

{

return &(interp->types.builtins[static_builtin_index_get(self)]);

}

static_builtin_state *

_PyStaticType_GetState(PyInterpreterState *interp, PyTypeObject *self)

{

assert(self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN);

return static_builtin_state_get(interp, self);

}

static void

static_builtin_state_init(PyInterpreterState *interp, PyTypeObject *self)

{

if (!static_builtin_index_is_set(self)) {

static_builtin_index_set(self, interp->types.num_builtins_initialized);

}

static_builtin_state *state = static_builtin_state_get(interp, self);

/* It should only be called once for each builtin type. */

assert(state->type == NULL);

state->type = self;

/* state->tp_subclasses is left NULL until init_subclasses() sets it. */

/* state->tp_weaklist is left NULL until insert_head() or insert_after()

interp->types.num_builtins_initialized++;

}

static void

static_builtin_state_clear(PyInterpreterState *interp, PyTypeObject *self)

{

static_builtin_state *state = static_builtin_state_get(interp, self);

assert(state->type != NULL);

state->type = NULL;

assert(state->tp_weaklist == NULL); // It was already cleared out.

if (_Py_IsMainInterpreter(interp)) {

static_builtin_index_clear(self);

}

assert(interp->types.num_builtins_initialized > 0);

interp->types.num_builtins_initialized--;

}

static inline void

start_readying(PyTypeObject *type)

{

if (type->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = static_builtin_state_get(interp, type);

assert(state != NULL);

assert(!state->readying);

state->readying = 1;

return;

}

assert((type->tp_flags & Py_TPFLAGS_READYING) == 0);

type->tp_flags |= Py_TPFLAGS_READYING;

}

static inline void

stop_readying(PyTypeObject *type)

{

if (type->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = static_builtin_state_get(interp, type);

assert(state != NULL);

assert(state->readying);

state->readying = 0;

return;

}

assert(type->tp_flags & Py_TPFLAGS_READYING);

type->tp_flags &= ~Py_TPFLAGS_READYING;

}

static inline int

is_readying(PyTypeObject *type)

{

if (type->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = static_builtin_state_get(interp, type);

assert(state != NULL);

return state->readying;

}

return (type->tp_flags & Py_TPFLAGS_READYING) != 0;

}

static inline PyObject *

lookup_tp_dict(PyTypeObject *self)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

assert(state != NULL);

return state->tp_dict;

}

return self->tp_dict;

}

PyObject *

_PyType_GetDict(PyTypeObject *self)

{

/* It returns a borrowed reference. */

return lookup_tp_dict(self);

}

PyObject *

PyType_GetDict(PyTypeObject *self)

{

PyObject *dict = lookup_tp_dict(self);

return _Py_XNewRef(dict);

}

static inline void

set_tp_dict(PyTypeObject *self, PyObject *dict)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

assert(state != NULL);

state->tp_dict = dict;

return;

}

self->tp_dict = dict;

}

static inline void

clear_tp_dict(PyTypeObject *self)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

assert(state != NULL);

Py_CLEAR(state->tp_dict);

return;

}

Py_CLEAR(self->tp_dict);

}

static inline PyObject *

lookup_tp_bases(PyTypeObject *self)

{

return self->tp_bases;

}

PyObject *

_PyType_GetBases(PyTypeObject *self)

{

/* It returns a borrowed reference. */

return lookup_tp_bases(self);

}

static inline void

set_tp_bases(PyTypeObject *self, PyObject *bases)

{

assert(PyTuple_CheckExact(bases));

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

// XXX tp_bases can probably be statically allocated for each

// static builtin type.

assert(_Py_IsMainInterpreter(_PyInterpreterState_GET()));

assert(self->tp_bases == NULL);

if (PyTuple_GET_SIZE(bases) == 0) {

assert(self->tp_base == NULL);

}

else {

assert(PyTuple_GET_SIZE(bases) == 1);

assert(PyTuple_GET_ITEM(bases, 0) == (PyObject *)self->tp_base);

assert(self->tp_base->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN);

assert(_Py_IsImmortal(self->tp_base));

}

_Py_SetImmortal(bases);

}

self->tp_bases = bases;

}

static inline void

clear_tp_bases(PyTypeObject *self)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

if (_Py_IsMainInterpreter(_PyInterpreterState_GET())) {

if (self->tp_bases != NULL) {

if (PyTuple_GET_SIZE(self->tp_bases) == 0) {

Py_CLEAR(self->tp_bases);

}

else {

assert(_Py_IsImmortal(self->tp_bases));

_Py_ClearImmortal(self->tp_bases);

}

}

}

return;

}

Py_CLEAR(self->tp_bases);

}

static inline PyObject *

lookup_tp_mro(PyTypeObject *self)

{

return self->tp_mro;

}

PyObject *

_PyType_GetMRO(PyTypeObject *self)

{

/* It returns a borrowed reference. */

return lookup_tp_mro(self);

}

static inline void

set_tp_mro(PyTypeObject *self, PyObject *mro)

{

assert(PyTuple_CheckExact(mro));

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

// XXX tp_mro can probably be statically allocated for each

// static builtin type.

assert(_Py_IsMainInterpreter(_PyInterpreterState_GET()));

assert(self->tp_mro == NULL);

/* Other checks are done via set_tp_bases. */

_Py_SetImmortal(mro);

}

self->tp_mro = mro;

}

static inline void

clear_tp_mro(PyTypeObject *self)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

if (_Py_IsMainInterpreter(_PyInterpreterState_GET())) {

if (self->tp_mro != NULL) {

if (PyTuple_GET_SIZE(self->tp_mro) == 0) {

Py_CLEAR(self->tp_mro);

}

else {

assert(_Py_IsImmortal(self->tp_mro));

_Py_ClearImmortal(self->tp_mro);

}

}

}

return;

}

Py_CLEAR(self->tp_mro);

}

static PyObject *

init_tp_subclasses(PyTypeObject *self)

{

PyObject *subclasses = PyDict_New();

if (subclasses == NULL) {

return NULL;

}

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

state->tp_subclasses = subclasses;

return subclasses;

}

self->tp_subclasses = (void *)subclasses;

return subclasses;

}

static void

clear_tp_subclasses(PyTypeObject *self)

{

/* Delete the dictionary to save memory. _PyStaticType_Dealloc()

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

Py_CLEAR(state->tp_subclasses);

return;

}

Py_CLEAR(self->tp_subclasses);

}

static inline PyObject *

lookup_tp_subclasses(PyTypeObject *self)

{

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {

PyInterpreterState *interp = _PyInterpreterState_GET();

static_builtin_state *state = _PyStaticType_GetState(interp, self);

assert(state != NULL);

return state->tp_subclasses;

}

return (PyObject *)self->tp_subclasses;

}

_PyType_HasSubclasses(PyTypeObject *self)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN

// XXX _PyStaticType_GetState() should never return NULL.

&& _PyStaticType_GetState(interp, self) == NULL)

{

return 0;

}

if (lookup_tp_subclasses(self) == NULL) {

return 0;

}

return 1;

}

_PyType_GetSubclasses(PyTypeObject *self)

{

PyObject *list = PyList_New(0);

if (list == NULL) {

return NULL;

}

PyObject *subclasses = lookup_tp_subclasses(self); // borrowed ref

if (subclasses == NULL) {

return list;

}

assert(PyDict_CheckExact(subclasses));

// The loop cannot modify tp_subclasses, there is no need

// to hold a strong reference (use a borrowed reference).

Py_ssize_t i = 0;

PyObject *ref; // borrowed ref

while (PyDict_Next(subclasses, &i, NULL, &ref)) {

PyTypeObject *subclass = type_from_ref(ref); // borrowed

if (subclass == NULL) {

continue;

}

if (PyList_Append(list, _PyObject_CAST(subclass)) < 0) {

Py_DECREF(list);

return NULL;

}

}

return list;

}

static const char *

find_signature(const char *name, const char *doc)

{

const char *dot;

size_t length;

if (!doc)

return NULL;

assert(name != NULL);

/* for dotted names like classes, only use the last component */

dot = strrchr(name, '.');

if (dot)

name = dot + 1;

length = strlen(name);

if (strncmp(doc, name, length))

return NULL;

doc += length;

if (*doc != '(')

return NULL;

return doc;

}

#define SIGNATURE_END_MARKER ")\n--\n\n"

#define SIGNATURE_END_MARKER_LENGTH 6

static const char *

skip_signature(const char *doc)

{

while (*doc) {

if ((*doc == *SIGNATURE_END_MARKER) &&

!strncmp(doc, SIGNATURE_END_MARKER, SIGNATURE_END_MARKER_LENGTH))

return doc + SIGNATURE_END_MARKER_LENGTH;

if ((*doc == '\n') && (doc[1] == '\n'))

return NULL;

doc++;

}

return NULL;

}

_PyType_CheckConsistency(PyTypeObject *type)

{

#define CHECK(expr) \

do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG((PyObject *)type, Py_STRINGIFY(expr)); } } while (0)

CHECK(!_PyObject_IsFreed((PyObject *)type));

if (!(type->tp_flags & Py_TPFLAGS_READY)) {

/* don't check static types before PyType_Ready() */

return 1;

}

CHECK(Py_REFCNT(type) >= 1);

CHECK(PyType_Check(type));

CHECK(!is_readying(type));

CHECK(lookup_tp_dict(type) != NULL);

if (type->tp_flags & Py_TPFLAGS_HAVE_GC) {

// bpo-44263: tp_traverse is required if Py_TPFLAGS_HAVE_GC is set.

// Note: tp_clear is optional.

CHECK(type->tp_traverse != NULL);

}

if (type->tp_flags & Py_TPFLAGS_DISALLOW_INSTANTIATION) {

CHECK(type->tp_new == NULL);

CHECK(PyDict_Contains(lookup_tp_dict(type), &_Py_ID(__new__)) == 0);

}

return 1;

#undef CHECK

}

static const char *

_PyType_DocWithoutSignature(const char *name, const char *internal_doc)

{

const char *doc = find_signature(name, internal_doc);

if (doc) {

doc = skip_signature(doc);

if (doc)

return doc;

}

return internal_doc;

}

PyObject *

_PyType_GetDocFromInternalDoc(const char *name, const char *internal_doc)

{

const char *doc = _PyType_DocWithoutSignature(name, internal_doc);

if (!doc || *doc == '\0') {

Py_RETURN_NONE;

}

return PyUnicode_FromString(doc);

}

PyObject *

_PyType_GetTextSignatureFromInternalDoc(const char *name, const char *internal_doc)

{

const char *start = find_signature(name, internal_doc);

const char *end;

if (start)

end = skip_signature(start);

else

end = NULL;

if (!end) {

Py_RETURN_NONE;

}

/* back "end" up until it points just past the final ')' */

end -= SIGNATURE_END_MARKER_LENGTH - 1;

assert((end - start) >= 2); /* should be "()" at least */

assert(end[-1] == ')');

assert(end[0] == '\n');

return PyUnicode_FromStringAndSize(start, end - start);

}

static struct type_cache*

get_type_cache(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return &interp->types.type_cache;

}

static void

type_cache_clear(struct type_cache *cache, PyObject *value)

{

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

struct type_cache_entry *entry = &cache->hashtable[i];

entry->version = 0;

Py_XSETREF(entry->name, _Py_XNewRef(value));

entry->value = NULL;

}

}

_PyType_InitCache(PyInterpreterState *interp)

{

struct type_cache *cache = &interp->types.type_cache;

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

struct type_cache_entry *entry = &cache->hashtable[i];

assert(entry->name == NULL);

entry->version = 0;

// Set to None so _PyType_Lookup() can use Py_SETREF(),

// rather than using slower Py_XSETREF().

entry->name = Py_None;

entry->value = NULL;

}

}

static unsigned int

_PyType_ClearCache(PyInterpreterState *interp)

{

struct type_cache *cache = &interp->types.type_cache;

// Set to None, rather than NULL, so _PyType_Lookup() can

// use Py_SETREF() rather than using slower Py_XSETREF().

type_cache_clear(cache, Py_None);

return NEXT_VERSION_TAG(interp) - 1;

}

PyType_ClearCache(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return _PyType_ClearCache(interp);

}

_PyTypes_Fini(PyInterpreterState *interp)

{

struct type_cache *cache = &interp->types.type_cache;

type_cache_clear(cache, NULL);

assert(interp->types.num_builtins_initialized == 0);

// All the static builtin types should have been finalized already.

for (size_t i = 0; i < _Py_MAX_STATIC_BUILTIN_TYPES; i++) {

assert(interp->types.builtins[i].type == NULL);

}

}

PyType_AddWatcher(PyType_WatchCallback callback)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

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

if (!interp->type_watchers[i]) {

interp->type_watchers[i] = callback;

return i;

}

}

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

return -1;

}

static inline int

validate_watcher_id(PyInterpreterState *interp, int watcher_id)

{

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

PyErr_Format(PyExc_ValueError, "Invalid type watcher ID %d", watcher_id);

return -1;

}

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

PyErr_Format(PyExc_ValueError, "No type watcher set for ID %d", watcher_id);

return -1;

}

return 0;

}

PyType_ClearWatcher(int watcher_id)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

if (validate_watcher_id(interp, watcher_id) < 0) {

return -1;

}

interp->type_watchers[watcher_id] = NULL;

return 0;

}

static int assign_version_tag(PyInterpreterState *interp, PyTypeObject *type);

PyType_Watch(int watcher_id, PyObject* obj)

{

if (!PyType_Check(obj)) {

PyErr_SetString(PyExc_ValueError, "Cannot watch non-type");

return -1;

}

PyTypeObject *type = (PyTypeObject *)obj;

PyInterpreterState *interp = _PyInterpreterState_GET();

if (validate_watcher_id(interp, watcher_id) < 0) {

return -1;

}

// ensure we will get a callback on the next modification

assign_version_tag(interp, type);

type->tp_watched |= (1 << watcher_id);

return 0;

}

PyType_Unwatch(int watcher_id, PyObject* obj)

{

if (!PyType_Check(obj)) {

PyErr_SetString(PyExc_ValueError, "Cannot watch non-type");

return -1;

}

PyTypeObject *type = (PyTypeObject *)obj;

PyInterpreterState *interp = _PyInterpreterState_GET();

if (validate_watcher_id(interp, watcher_id)) {

return -1;

}

type->tp_watched &= ~(1 << watcher_id);

return 0;

}

PyType_Modified(PyTypeObject *type)

{

/* Invalidate any cached data for the specified type and all

if (!_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {

return;

}

PyObject *subclasses = lookup_tp_subclasses(type);

if (subclasses != NULL) {

assert(PyDict_CheckExact(subclasses));

Py_ssize_t i = 0;

PyObject *ref;

while (PyDict_Next(subclasses, &i, NULL, &ref)) {

PyTypeObject *subclass = type_from_ref(ref); // borrowed

if (subclass == NULL) {

continue;

}

PyType_Modified(subclass);

}

}

// Notify registered type watchers, if any

if (type->tp_watched) {

PyInterpreterState *interp = _PyInterpreterState_GET();

int bits = type->tp_watched;

int i = 0;

while (bits) {

assert(i < TYPE_MAX_WATCHERS);

if (bits & 1) {

PyType_WatchCallback cb = interp->type_watchers[i];

if (cb && (cb(type) < 0)) {

PyErr_WriteUnraisable((PyObject *)type);

}

}

i++;

bits >>= 1;

}

}

type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;

type->tp_version_tag = 0; /* 0 is not a valid version tag */

if (PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE)) {

// This field *must* be invalidated if the type is modified (see the

// comment on struct _specialization_cache):

((PyHeapTypeObject *)type)->_spec_cache.getitem = NULL;

}

}

static void

type_mro_modified(PyTypeObject *type, PyObject *bases) {

/*

Py_ssize_t i, n;

int custom = !Py_IS_TYPE(type, &PyType_Type);

int unbound;

if (custom) {

PyObject *mro_meth, *type_mro_meth;

mro_meth = lookup_maybe_method(

(PyObject *)type, &_Py_ID(mro), &unbound);

if (mro_meth == NULL) {

goto clear;

}

type_mro_meth = lookup_maybe_method(

(PyObject *)&PyType_Type, &_Py_ID(mro), &unbound);

if (type_mro_meth == NULL) {

Py_DECREF(mro_meth);

goto clear;

}

int custom_mro = (mro_meth != type_mro_meth);

Py_DECREF(mro_meth);

Py_DECREF(type_mro_meth);

if (custom_mro) {

goto clear;

}

}

n = PyTuple_GET_SIZE(bases);

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

PyObject *b = PyTuple_GET_ITEM(bases, i);

PyTypeObject *cls = _PyType_CAST(b);

if (!PyType_IsSubtype(type, cls)) {

goto clear;

}

}

return;

clear:

assert(!(type->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN));

type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;

type->tp_version_tag = 0; /* 0 is not a valid version tag */

if (PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE)) {

// This field *must* be invalidated if the type is modified (see the

// comment on struct _specialization_cache):

((PyHeapTypeObject *)type)->_spec_cache.getitem = NULL;

}

}

static int

assign_version_tag(PyInterpreterState *interp, PyTypeObject *type)

{

/* Ensure that the tp_version_tag is valid and set

if (_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {

return 1;

}

if (!_PyType_HasFeature(type, Py_TPFLAGS_READY)) {

return 0;

}

if (type->tp_flags & Py_TPFLAGS_IMMUTABLETYPE) {

/* static types */

if (NEXT_GLOBAL_VERSION_TAG > _Py_MAX_GLOBAL_TYPE_VERSION_TAG) {

/* We have run out of version numbers */

return 0;

}

type->tp_version_tag = NEXT_GLOBAL_VERSION_TAG++;

assert (type->tp_version_tag <= _Py_MAX_GLOBAL_TYPE_VERSION_TAG);

}

else {

/* heap types */

if (NEXT_VERSION_TAG(interp) == 0) {

/* We have run out of version numbers */

return 0;

}

type->tp_version_tag = NEXT_VERSION_TAG(interp)++;

assert (type->tp_version_tag != 0);

}

PyObject *bases = lookup_tp_bases(type);

Py_ssize_t n = PyTuple_GET_SIZE(bases);

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

PyObject *b = PyTuple_GET_ITEM(bases, i);

if (!assign_version_tag(interp, _PyType_CAST(b)))

return 0;

}

type->tp_flags |= Py_TPFLAGS_VALID_VERSION_TAG;

return 1;

}

int PyUnstable_Type_AssignVersionTag(PyTypeObject *type)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return assign_version_tag(interp, type);

}

static PyMemberDef type_members[] = {

{"__basicsize__", T_PYSSIZET, offsetof(PyTypeObject,tp_basicsize),READONLY},

{"__itemsize__", T_PYSSIZET, offsetof(PyTypeObject, tp_itemsize), READONLY},

{"__flags__", T_ULONG, offsetof(PyTypeObject, tp_flags), READONLY},

/* Note that this value is misleading for static builtin types,

{"__weakrefoffset__", T_PYSSIZET,

offsetof(PyTypeObject, tp_weaklistoffset), READONLY},

{"__base__", T_OBJECT, offsetof(PyTypeObject, tp_base), READONLY},

{"__dictoffset__", T_PYSSIZET,

offsetof(PyTypeObject, tp_dictoffset), READONLY},

{0}

};

static int

check_set_special_type_attr(PyTypeObject *type, PyObject *value, const char *name)

{

if (_PyType_HasFeature(type, Py_TPFLAGS_IMMUTABLETYPE)) {

PyErr_Format(PyExc_TypeError,

"cannot set '%s' attribute of immutable type '%s'",

name, type->tp_name);

return 0;

}

if (!value) {

PyErr_Format(PyExc_TypeError,

"cannot delete '%s' attribute of immutable type '%s'",

name, type->tp_name);

return 0;

}

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

type, name, value) < 0) {

return 0;

}

return 1;

}

const char *

_PyType_Name(PyTypeObject *type)

{

assert(type->tp_name != NULL);

const char *s = strrchr(type->tp_name, '.');

if (s == NULL) {

s = type->tp_name;

}

else {

s++;

}

return s;

}

static PyObject *

type_name(PyTypeObject *type, void *context)

{

if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {

PyHeapTypeObject* et = (PyHeapTypeObject*)type;

return Py_NewRef(et->ht_name);

}

else {

return PyUnicode_FromString(_PyType_Name(type));

}

}