/* Type object implementation */

#include "Python.h"

#include "structmember.h"

#include <ctype.h>

/* Support type attribute cache */

/* The cache can keep references to the names alive for longer than

   they normally would.  This is why the maximum size is limited to

   MCACHE_MAX_ATTR_SIZE, since it might be a problem if very large

   strings are used as attribute names. */

#define MCACHE_MAX_ATTR_SIZE	100

#define MCACHE_SIZE_EXP		10

#define MCACHE_HASH(version, name_hash)					\

		(((unsigned int)(version) * (unsigned int)(name_hash))	\

		 >> (8*sizeof(unsigned int) - MCACHE_SIZE_EXP))

#define MCACHE_HASH_METHOD(type, name)                                  \

		MCACHE_HASH((type)->tp_version_tag,                     \

		            ((PyStringObject *)(name))->ob_shash)

#define MCACHE_CACHEABLE_NAME(name)                                     \

		PyString_CheckExact(name) &&                            \

		PyString_GET_SIZE(name) <= MCACHE_MAX_ATTR_SIZE

struct method_cache_entry {

	unsigned int version;

	PyObject *name;		/* reference to exactly a str or None */

	PyObject *value;	/* borrowed */

};

static struct method_cache_entry method_cache[1 << MCACHE_SIZE_EXP];

static unsigned int next_version_tag = 0;

unsigned int

PyType_ClearCache(void)

{

	Py_ssize_t i;

	unsigned int cur_version_tag = next_version_tag - 1;

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

		method_cache[i].version = 0;

		Py_CLEAR(method_cache[i].name);

		method_cache[i].value = NULL;

	}

	next_version_tag = 0;

	/* mark all version tags as invalid */

	PyType_Modified(&PyBaseObject_Type);

	return cur_version_tag;

}

void

PyType_Modified(PyTypeObject *type)

{

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

	   subclasses.  This function is called after the base

	   classes, mro, or attributes of the type are altered.

	   Invariants:

	   - Py_TPFLAGS_VALID_VERSION_TAG is never set if

	     Py_TPFLAGS_HAVE_VERSION_TAG is not set (e.g. on type

	     objects coming from non-recompiled extension modules)

	   - before Py_TPFLAGS_VALID_VERSION_TAG can be set on a type,

	     it must first be set on all super types.

	   This function clears the Py_TPFLAGS_VALID_VERSION_TAG of a

	   type (so it must first clear it on all subclasses).  The

	   tp_version_tag value is meaningless unless this flag is set.

	   We don't assign new version tags eagerly, but only as

	   needed.

	 */

	PyObject *raw, *ref;

	Py_ssize_t i, n;

	if (!PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG))

		return;

	raw = type->tp_subclasses;

	if (raw != NULL) {

		n = PyList_GET_SIZE(raw);

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

			ref = PyList_GET_ITEM(raw, i);

			ref = PyWeakref_GET_OBJECT(ref);

			if (ref != Py_None) {

				PyType_Modified((PyTypeObject *)ref);

			}

		}

	}

	type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;

}

static void

type_mro_modified(PyTypeObject *type, PyObject *bases) {

	/*

	   Check that all base classes or elements of the mro of type are

	   able to be cached.  This function is called after the base

	   classes or mro of the type are altered.

	   Unset HAVE_VERSION_TAG and VALID_VERSION_TAG if the type

	   inherits from an old-style class, either directly or if it

	   appears in the MRO of a new-style class.  No support either for

	   custom MROs that include types that are not officially super

	   types.

	   Called from mro_internal, which will subsequently be called on

	   each subclass when their mro is recursively updated.

	 */

	Py_ssize_t i, n;

	int clear = 0;

	if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_VERSION_TAG))

		return;

	n = PyTuple_GET_SIZE(bases);

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

		PyObject *b = PyTuple_GET_ITEM(bases, i);

		PyTypeObject *cls;

		if (!PyType_Check(b) ) {

			clear = 1;

			break;

		}

		cls = (PyTypeObject *)b;

		if (!PyType_HasFeature(cls, Py_TPFLAGS_HAVE_VERSION_TAG) ||

		    !PyType_IsSubtype(type, cls)) {

			clear = 1;

			break;

		}

	}

	if (clear)

		type->tp_flags &= ~(Py_TPFLAGS_HAVE_VERSION_TAG|

		                    Py_TPFLAGS_VALID_VERSION_TAG);

}

static int

assign_version_tag(PyTypeObject *type)

{

	/* Ensure that the tp_version_tag is valid and set

	   Py_TPFLAGS_VALID_VERSION_TAG.  To respect the invariant, this

	   must first be done on all super classes.  Return 0 if this

	   cannot be done, 1 if Py_TPFLAGS_VALID_VERSION_TAG.

	*/

	Py_ssize_t i, n;

	PyObject *bases;

	if (PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG))

		return 1;

	if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_VERSION_TAG))

		return 0;

	if (!PyType_HasFeature(type, Py_TPFLAGS_READY))

		return 0;

	type->tp_version_tag = next_version_tag++;

	/* for stress-testing: next_version_tag &= 0xFF; */

	if (type->tp_version_tag == 0) {

		/* wrap-around or just starting Python - clear the whole

		   cache by filling names with references to Py_None.

		   Values are also set to NULL for added protection, as they

		   are borrowed reference */

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

			method_cache[i].value = NULL;

			Py_XDECREF(method_cache[i].name);

			method_cache[i].name = Py_None;

			Py_INCREF(Py_None);

		}

		/* mark all version tags as invalid */

		PyType_Modified(&PyBaseObject_Type);

		return 1;

	}

	bases = type->tp_bases;

	n = PyTuple_GET_SIZE(bases);

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

		PyObject *b = PyTuple_GET_ITEM(bases, i);

		assert(PyType_Check(b));

		if (!assign_version_tag((PyTypeObject *)b))

			return 0;

	}

	type->tp_flags |= Py_TPFLAGS_VALID_VERSION_TAG;

	return 1;

}

static PyMemberDef type_members[] = {

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

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

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

	{"__weakrefoffset__", T_LONG,

	 offsetof(PyTypeObject, tp_weaklistoffset), READONLY},

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

	{"__dictoffset__", T_LONG,

	 offsetof(PyTypeObject, tp_dictoffset), READONLY},

	{"__mro__", T_OBJECT, offsetof(PyTypeObject, tp_mro), READONLY},

	{0}

};

static PyObject *

type_name(PyTypeObject *type, void *context)

{

	const char *s;

	if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {

		PyHeapTypeObject* et = (PyHeapTypeObject*)type;

		Py_INCREF(et->ht_name);

		return et->ht_name;

	}

	else {

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

		if (s == NULL)

			s = type->tp_name;

		else

			s++;

		return PyString_FromString(s);

	}

}

static int

type_set_name(PyTypeObject *type, PyObject *value, void *context)

{

	PyHeapTypeObject* et;

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

		PyErr_Format(PyExc_TypeError,

			     "can't set %s.__name__", type->tp_name);

		return -1;

	}

	if (!value) {

		PyErr_Format(PyExc_TypeError,

			     "can't delete %s.__name__", type->tp_name);

		return -1;

	}

	if (!PyString_Check(value)) {

		PyErr_Format(PyExc_TypeError,

			     "can only assign string to %s.__name__, not '%s'",

			     type->tp_name, Py_TYPE(value)->tp_name);

		return -1;

	}

	if (strlen(PyString_AS_STRING(value))

	    != (size_t)PyString_GET_SIZE(value)) {

		PyErr_Format(PyExc_ValueError,

			     "__name__ must not contain null bytes");

		return -1;

	}

	et = (PyHeapTypeObject*)type;

	Py_INCREF(value);

	Py_DECREF(et->ht_name);

	et->ht_name = value;

	type->tp_name = PyString_AS_STRING(value);

	return 0;

}

static PyObject *

type_module(PyTypeObject *type, void *context)

{

	PyObject *mod;

	char *s;

	if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {

		mod = PyDict_GetItemString(type->tp_dict, "__module__");

		if (!mod) { 

			PyErr_Format(PyExc_AttributeError, "__module__");

			return 0;

		}

		Py_XINCREF(mod);

		return mod;

	}

	else {

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

		if (s != NULL)

			return PyString_FromStringAndSize(

			    type->tp_name, (Py_ssize_t)(s - type->tp_name));

		return PyString_FromString("__builtin__");

	}

}

static int

type_set_module(PyTypeObject *type, PyObject *value, void *context)

{

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

		PyErr_Format(PyExc_TypeError,

			     "can't set %s.__module__", type->tp_name);

		return -1;

	}

	if (!value) {

		PyErr_Format(PyExc_TypeError,

			     "can't delete %s.__module__", type->tp_name);

		return -1;

	}

	PyType_Modified(type);

	return PyDict_SetItemString(type->tp_dict, "__module__", value);

}

static PyObject *

type_abstractmethods(PyTypeObject *type, void *context)

{

	PyObject *mod = PyDict_GetItemString(type->tp_dict,

					     "__abstractmethods__");

	if (!mod) {

		PyErr_Format(PyExc_AttributeError, "__abstractmethods__");

		return NULL;

	}

	Py_XINCREF(mod);

	return mod;

}

static int

type_set_abstractmethods(PyTypeObject *type, PyObject *value, void *context)

{

	/* __abstractmethods__ should only be set once on a type, in

	   abc.ABCMeta.__new__, so this function doesn't do anything

	   special to update subclasses.

	*/

	int res = PyDict_SetItemString(type->tp_dict,

				       "__abstractmethods__", value);

	if (res == 0) {

		PyType_Modified(type);

		if (value && PyObject_IsTrue(value)) {

			type->tp_flags |= Py_TPFLAGS_IS_ABSTRACT;

		}

		else {

			type->tp_flags &= ~Py_TPFLAGS_IS_ABSTRACT;

		}

	}

	return res;

}

static PyObject *

type_get_bases(PyTypeObject *type, void *context)

{

	Py_INCREF(type->tp_bases);

	return type->tp_bases;

}

static PyTypeObject *best_base(PyObject *);

static int mro_internal(PyTypeObject *);

static int compatible_for_assignment(PyTypeObject *, PyTypeObject *, char *);

static int add_subclass(PyTypeObject*, PyTypeObject*);

static void remove_subclass(PyTypeObject *, PyTypeObject *);

static void update_all_slots(PyTypeObject *);

typedef int (*update_callback)(PyTypeObject *, void *);

static int update_subclasses(PyTypeObject *type, PyObject *name,

			     update_callback callback, void *data);

static int recurse_down_subclasses(PyTypeObject *type, PyObject *name,

				   update_callback callback, void *data);

static int

mro_subclasses(PyTypeObject *type, PyObject* temp)

{

	PyTypeObject *subclass;

	PyObject *ref, *subclasses, *old_mro;

	Py_ssize_t i, n;

	subclasses = type->tp_subclasses;

	if (subclasses == NULL)

		return 0;

	assert(PyList_Check(subclasses));

	n = PyList_GET_SIZE(subclasses);

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

		ref = PyList_GET_ITEM(subclasses, i);

		assert(PyWeakref_CheckRef(ref));

		subclass = (PyTypeObject *)PyWeakref_GET_OBJECT(ref);

		assert(subclass != NULL);

		if ((PyObject *)subclass == Py_None)

			continue;

		assert(PyType_Check(subclass));

		old_mro = subclass->tp_mro;

		if (mro_internal(subclass) < 0) {

			subclass->tp_mro = old_mro;

			return -1;

		}

		else {

			PyObject* tuple;

			tuple = PyTuple_Pack(2, subclass, old_mro);

			Py_DECREF(old_mro);

			if (!tuple)

				return -1;

			if (PyList_Append(temp, tuple) < 0)

				return -1;

			Py_DECREF(tuple);

		}

		if (mro_subclasses(subclass, temp) < 0)

			return -1;

	}

	return 0;

}

static int

type_set_bases(PyTypeObject *type, PyObject *value, void *context)

{

	Py_ssize_t i;

	int r = 0;

	PyObject *ob, *temp;

	PyTypeObject *new_base, *old_base;

	PyObject *old_bases, *old_mro;

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

		PyErr_Format(PyExc_TypeError,

			     "can't set %s.__bases__", type->tp_name);

		return -1;

	}

	if (!value) {

		PyErr_Format(PyExc_TypeError,

			     "can't delete %s.__bases__", type->tp_name);

		return -1;

	}

	if (!PyTuple_Check(value)) {

		PyErr_Format(PyExc_TypeError,

		     "can only assign tuple to %s.__bases__, not %s",

			     type->tp_name, Py_TYPE(value)->tp_name);

		return -1;

	}

	if (PyTuple_GET_SIZE(value) == 0) {

		PyErr_Format(PyExc_TypeError,

		     "can only assign non-empty tuple to %s.__bases__, not ()",

			     type->tp_name);

		return -1;

	}

	for (i = 0; i < PyTuple_GET_SIZE(value); i++) {

		ob = PyTuple_GET_ITEM(value, i);

		if (!PyClass_Check(ob) && !PyType_Check(ob)) {

			PyErr_Format(

				PyExc_TypeError,

	"%s.__bases__ must be tuple of old- or new-style classes, not '%s'",

				type->tp_name, Py_TYPE(ob)->tp_name);

			return -1;

		}

		if (PyType_Check(ob)) {

			if (PyType_IsSubtype((PyTypeObject*)ob, type)) {

				PyErr_SetString(PyExc_TypeError,

			"a __bases__ item causes an inheritance cycle");

				return -1;

			}

		}

	}

	new_base = best_base(value);

	if (!new_base) {

		return -1;

	}

	if (!compatible_for_assignment(type->tp_base, new_base, "__bases__"))

		return -1;

	Py_INCREF(new_base);

	Py_INCREF(value);

	old_bases = type->tp_bases;

	old_base = type->tp_base;

	old_mro = type->tp_mro;

	type->tp_bases = value;

	type->tp_base = new_base;

	if (mro_internal(type) < 0) {

		goto bail;

	}

	temp = PyList_New(0);

	if (!temp)

		goto bail;

	r = mro_subclasses(type, temp);

	if (r < 0) {

		for (i = 0; i < PyList_Size(temp); i++) {

			PyTypeObject* cls;

			PyObject* mro;

			PyArg_UnpackTuple(PyList_GET_ITEM(temp, i),

					 "", 2, 2, &cls, &mro);

			Py_INCREF(mro);

			ob = cls->tp_mro;

			cls->tp_mro = mro;

			Py_DECREF(ob);

		}

		Py_DECREF(temp);

		goto bail;

	}

	Py_DECREF(temp);

	/* any base that was in __bases__ but now isn't, we

	   need to remove |type| from its tp_subclasses.

	   conversely, any class now in __bases__ that wasn't

	   needs to have |type| added to its subclasses. */

	/* for now, sod that: just remove from all old_bases,

	   add to all new_bases */

	for (i = PyTuple_GET_SIZE(old_bases) - 1; i >= 0; i--) {

		ob = PyTuple_GET_ITEM(old_bases, i);

		if (PyType_Check(ob)) {

			remove_subclass(

				(PyTypeObject*)ob, type);

		}

	}

	for (i = PyTuple_GET_SIZE(value) - 1; i >= 0; i--) {

		ob = PyTuple_GET_ITEM(value, i);

		if (PyType_Check(ob)) {

			if (add_subclass((PyTypeObject*)ob, type) < 0)

				r = -1;

		}

	}

	update_all_slots(type);

	Py_DECREF(old_bases);

	Py_DECREF(old_base);

	Py_DECREF(old_mro);

	return r;

  bail: