/* Generic object operations; and implementation of None (NoObject) */

#include "Python.h"

#ifdef __cplusplus

extern "C" {

#endif

#ifdef Py_REF_DEBUG

Py_ssize_t _Py_RefTotal;

Py_ssize_t

_Py_GetRefTotal(void)

{

	PyObject *o;

	Py_ssize_t total = _Py_RefTotal;

        /* ignore the references to the dummy object of the dicts and sets

           because they are not reliable and not useful (now that the

           hash table code is well-tested) */

	o = _PyDict_Dummy();

	if (o != NULL)

		total -= o->ob_refcnt;

	o = _PySet_Dummy();

	if (o != NULL)

		total -= o->ob_refcnt;

	return total;

}

#endif /* Py_REF_DEBUG */

int Py_DivisionWarningFlag;

int Py_Py3kWarningFlag;

/* Object allocation routines used by NEWOBJ and NEWVAROBJ macros.

   These are used by the individual routines for object creation.

   Do not call them otherwise, they do not initialize the object! */

#ifdef Py_TRACE_REFS

/* Head of circular doubly-linked list of all objects.  These are linked

 * together via the _ob_prev and _ob_next members of a PyObject, which

 * exist only in a Py_TRACE_REFS build.

 */

static PyObject refchain = {&refchain, &refchain};

/* Insert op at the front of the list of all objects.  If force is true,

 * op is added even if _ob_prev and _ob_next are non-NULL already.  If

 * force is false amd _ob_prev or _ob_next are non-NULL, do nothing.

 * force should be true if and only if op points to freshly allocated,

 * uninitialized memory, or you've unlinked op from the list and are

 * relinking it into the front.

 * Note that objects are normally added to the list via _Py_NewReference,

 * which is called by PyObject_Init.  Not all objects are initialized that

 * way, though; exceptions include statically allocated type objects, and

 * statically allocated singletons (like Py_True and Py_None).

 */

void

_Py_AddToAllObjects(PyObject *op, int force)

{

#ifdef  Py_DEBUG

	if (!force) {

		/* If it's initialized memory, op must be in or out of

		 * the list unambiguously.

		 */

		assert((op->_ob_prev == NULL) == (op->_ob_next == NULL));

	}

#endif

	if (force || op->_ob_prev == NULL) {

		op->_ob_next = refchain._ob_next;

		op->_ob_prev = &refchain;

		refchain._ob_next->_ob_prev = op;

		refchain._ob_next = op;

	}

}

#endif	/* Py_TRACE_REFS */

#ifdef COUNT_ALLOCS

static PyTypeObject *type_list;

/* All types are added to type_list, at least when

   they get one object created. That makes them

   immortal, which unfortunately contributes to

   garbage itself. If unlist_types_without_objects

   is set, they will be removed from the type_list

   once the last object is deallocated. */

int unlist_types_without_objects;

extern int tuple_zero_allocs, fast_tuple_allocs;

extern int quick_int_allocs, quick_neg_int_allocs;

extern int null_strings, one_strings;

void

dump_counts(FILE* f)

{

	PyTypeObject *tp;

	for (tp = type_list; tp; tp = tp->tp_next)

		fprintf(f, "%s alloc'd: %d, freed: %d, max in use: %d\n",

			tp->tp_name, tp->tp_allocs, tp->tp_frees,

			tp->tp_maxalloc);

	fprintf(f, "fast tuple allocs: %d, empty: %d\n",

		fast_tuple_allocs, tuple_zero_allocs);

	fprintf(f, "fast int allocs: pos: %d, neg: %d\n",

		quick_int_allocs, quick_neg_int_allocs);

	fprintf(f, "null strings: %d, 1-strings: %d\n",

		null_strings, one_strings);

}

PyObject *

get_counts(void)

{

	PyTypeObject *tp;

	PyObject *result;

	PyObject *v;

	result = PyList_New(0);

	if (result == NULL)

		return NULL;

	for (tp = type_list; tp; tp = tp->tp_next) {

		v = Py_BuildValue("(snnn)", tp->tp_name, tp->tp_allocs,

				  tp->tp_frees, tp->tp_maxalloc);

		if (v == NULL) {

			Py_DECREF(result);

			return NULL;

		}

		if (PyList_Append(result, v) < 0) {

			Py_DECREF(v);

			Py_DECREF(result);

			return NULL;

		}

		Py_DECREF(v);

	}

	return result;

}

void

inc_count(PyTypeObject *tp)

{

	if (tp->tp_next == NULL && tp->tp_prev == NULL) {

		/* first time; insert in linked list */

		if (tp->tp_next != NULL) /* sanity check */

			Py_FatalError("XXX inc_count sanity check");

		if (type_list)

			type_list->tp_prev = tp;

		tp->tp_next = type_list;

		/* Note that as of Python 2.2, heap-allocated type objects

		 * can go away, but this code requires that they stay alive

		 * until program exit.  That's why we're careful with

		 * refcounts here.  type_list gets a new reference to tp,

		 * while ownership of the reference type_list used to hold

		 * (if any) was transferred to tp->tp_next in the line above.

		 * tp is thus effectively immortal after this.

		 */

		Py_INCREF(tp);

		type_list = tp;

#ifdef Py_TRACE_REFS

		/* Also insert in the doubly-linked list of all objects,

		 * if not already there.

		 */

		_Py_AddToAllObjects((PyObject *)tp, 0);

#endif

	}

	tp->tp_allocs++;

	if (tp->tp_allocs - tp->tp_frees > tp->tp_maxalloc)

		tp->tp_maxalloc = tp->tp_allocs - tp->tp_frees;

}

void dec_count(PyTypeObject *tp)

{

	tp->tp_frees++;

	if (unlist_types_without_objects &&

	    tp->tp_allocs == tp->tp_frees) {

		/* unlink the type from type_list */

		if (tp->tp_prev)

			tp->tp_prev->tp_next = tp->tp_next;

		else

			type_list = tp->tp_next;

		if (tp->tp_next)

			tp->tp_next->tp_prev = tp->tp_prev;

		tp->tp_next = tp->tp_prev = NULL;

		Py_DECREF(tp);

	}

}

#endif

#ifdef Py_REF_DEBUG

/* Log a fatal error; doesn't return. */

void

_Py_NegativeRefcount(const char *fname, int lineno, PyObject *op)

{

	char buf[300];

	PyOS_snprintf(buf, sizeof(buf),

		      "%s:%i object at %p has negative ref count "

		      "%" PY_FORMAT_SIZE_T "d",

		      fname, lineno, op, op->ob_refcnt);

	Py_FatalError(buf);

}

#endif /* Py_REF_DEBUG */

void

Py_IncRef(PyObject *o)

{

    Py_XINCREF(o);

}

void

Py_DecRef(PyObject *o)

{

    Py_XDECREF(o);

}

PyObject *

PyObject_Init(PyObject *op, PyTypeObject *tp)

{

	if (op == NULL)

		return PyErr_NoMemory();

	/* Any changes should be reflected in PyObject_INIT (objimpl.h) */

	Py_TYPE(op) = tp;

	_Py_NewReference(op);

	return op;

}

PyVarObject *

PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, Py_ssize_t size)

{

	if (op == NULL)

		return (PyVarObject *) PyErr_NoMemory();

	/* Any changes should be reflected in PyObject_INIT_VAR */

	op->ob_size = size;

	Py_TYPE(op) = tp;

	_Py_NewReference((PyObject *)op);

	return op;

}

PyObject *

_PyObject_New(PyTypeObject *tp)

{

	PyObject *op;

	op = (PyObject *) PyObject_MALLOC(_PyObject_SIZE(tp));

	if (op == NULL)

		return PyErr_NoMemory();

	return PyObject_INIT(op, tp);

}

PyVarObject *

_PyObject_NewVar(PyTypeObject *tp, Py_ssize_t nitems)

{

	PyVarObject *op;

	const size_t size = _PyObject_VAR_SIZE(tp, nitems);

	op = (PyVarObject *) PyObject_MALLOC(size);

	if (op == NULL)

		return (PyVarObject *)PyErr_NoMemory();

	return PyObject_INIT_VAR(op, tp, nitems);

}

/* for binary compatibility with 2.2 */

#undef _PyObject_Del

void

_PyObject_Del(PyObject *op)

{

	PyObject_FREE(op);

}

/* Implementation of PyObject_Print with recursion checking */

static int

internal_print(PyObject *op, FILE *fp, int flags, int nesting)

{

	int ret = 0;

	if (nesting > 10) {

		PyErr_SetString(PyExc_RuntimeError, "print recursion");

		return -1;

	}

	if (PyErr_CheckSignals())

		return -1;

#ifdef USE_STACKCHECK

	if (PyOS_CheckStack()) {

		PyErr_SetString(PyExc_MemoryError, "stack overflow");

		return -1;

	}

#endif

	clearerr(fp); /* Clear any previous error condition */

	if (op == NULL) {

		Py_BEGIN_ALLOW_THREADS

		fprintf(fp, "<nil>");

		Py_END_ALLOW_THREADS

	}

	else {

		if (op->ob_refcnt <= 0)

			/* XXX(twouters) cast refcount to long until %zd is

			   universally available */

			Py_BEGIN_ALLOW_THREADS

			fprintf(fp, "<refcnt %ld at %p>",

				(long)op->ob_refcnt, op);

			Py_END_ALLOW_THREADS

		else if (Py_TYPE(op)->tp_print == NULL) {

			PyObject *s;

			if (flags & Py_PRINT_RAW)

				s = PyObject_Str(op);

			else

				s = PyObject_Repr(op);

			if (s == NULL)

				ret = -1;

			else {

				ret = internal_print(s, fp, Py_PRINT_RAW,

						     nesting+1);

			}

			Py_XDECREF(s);

		}

		else

			ret = (*Py_TYPE(op)->tp_print)(op, fp, flags);

	}

	if (ret == 0) {

		if (ferror(fp)) {

			PyErr_SetFromErrno(PyExc_IOError);

			clearerr(fp);

			ret = -1;

		}

	}

	return ret;

}

int

PyObject_Print(PyObject *op, FILE *fp, int flags)

{

	return internal_print(op, fp, flags, 0);

}

/* For debugging convenience.  See Misc/gdbinit for some useful gdb hooks */

void _PyObject_Dump(PyObject* op)

{

	if (op == NULL)

		fprintf(stderr, "NULL\n");

	else {

		fprintf(stderr, "object  : ");

		(void)PyObject_Print(op, stderr, 0);

		/* XXX(twouters) cast refcount to long until %zd is

		   universally available */

		fprintf(stderr, "\n"

			"type    : %s\n"

			"refcount: %ld\n"

			"address : %p\n",

			Py_TYPE(op)==NULL ? "NULL" : Py_TYPE(op)->tp_name,

			(long)op->ob_refcnt,

			op);

	}

}

PyObject *

PyObject_Repr(PyObject *v)

{

	if (PyErr_CheckSignals())

		return NULL;

#ifdef USE_STACKCHECK

	if (PyOS_CheckStack()) {

		PyErr_SetString(PyExc_MemoryError, "stack overflow");

		return NULL;

	}

#endif

	if (v == NULL)

		return PyString_FromString("<NULL>");

	else if (Py_TYPE(v)->tp_repr == NULL)

		return PyString_FromFormat("<%s object at %p>",

					   Py_TYPE(v)->tp_name, v);

	else {

		PyObject *res;

		res = (*Py_TYPE(v)->tp_repr)(v);

		if (res == NULL)

			return NULL;

#ifdef Py_USING_UNICODE

		if (PyUnicode_Check(res)) {

			PyObject* str;

			str = PyUnicode_AsEncodedString(res, NULL, NULL);

			Py_DECREF(res);

			if (str)

				res = str;

			else

				return NULL;

		}

#endif

		if (!PyString_Check(res)) {

			PyErr_Format(PyExc_TypeError,

				     "__repr__ returned non-string (type %.200s)",

				     Py_TYPE(res)->tp_name);

			Py_DECREF(res);

			return NULL;

		}

		return res;

	}

}

PyObject *

_PyObject_Str(PyObject *v)

{

	PyObject *res;

	int type_ok;

	if (v == NULL)

		return PyString_FromString("<NULL>");

	if (PyString_CheckExact(v)) {

		Py_INCREF(v);

		return v;

	}

#ifdef Py_USING_UNICODE

	if (PyUnicode_CheckExact(v)) {

		Py_INCREF(v);

		return v;

	}

#endif

	if (Py_TYPE(v)->tp_str == NULL)

		return PyObject_Repr(v);

	/* It is possible for a type to have a tp_str representation that loops

	   infinitely. */

	if (Py_EnterRecursiveCall(" while getting the str of an object"))

		return NULL;

	res = (*Py_TYPE(v)->tp_str)(v);

	Py_LeaveRecursiveCall();

	if (res == NULL)

		return NULL;

	type_ok = PyString_Check(res);

#ifdef Py_USING_UNICODE

	type_ok = type_ok || PyUnicode_Check(res);

#endif

	if (!type_ok) {

		PyErr_Format(PyExc_TypeError,

			     "__str__ returned non-string (type %.200s)",

			     Py_TYPE(res)->tp_name);

		Py_DECREF(res);

		return NULL;

	}

	return res;

}

PyObject *

PyObject_Str(PyObject *v)

{

	PyObject *res = _PyObject_Str(v);

	if (res == NULL)

		return NULL;

#ifdef Py_USING_UNICODE

	if (PyUnicode_Check(res)) {

		PyObject* str;

		str = PyUnicode_AsEncodedString(res, NULL, NULL);

		Py_DECREF(res);

		if (str)

			res = str;

		else

		    	return NULL;

	}

#endif

	assert(PyString_Check(res));

	return res;

}

#ifdef Py_USING_UNICODE

PyObject *

PyObject_Unicode(PyObject *v)

{

	PyObject *res;

	PyObject *func;

	PyObject *str;

	int unicode_method_found = 0;

	static PyObject *unicodestr;

	if (v == NULL) {

		res = PyString_FromString("<NULL>");

		if (res == NULL)

			return NULL;

		str = PyUnicode_FromEncodedObject(res, NULL, "strict");

		Py_DECREF(res);

		return str;

	} else if (PyUnicode_CheckExact(v)) {

		Py_INCREF(v);

		return v;

	}

	/* Try the __unicode__ method */

	if (unicodestr == NULL) {

		unicodestr= PyString_InternFromString("__unicode__");

		if (unicodestr == NULL)

			return NULL;

	}

	if (PyInstance_Check(v)) {

		/* We're an instance of a classic class */

		/* Try __unicode__ from the instance -- alas we have no type */

		func = PyObject_GetAttr(v, unicodestr);

		if (func != NULL) {

			unicode_method_found = 1;

			res = PyObject_CallFunctionObjArgs(func, NULL);

			Py_DECREF(func);

		}

		else {

			PyErr_Clear(); 

		}

	}

	else {

		/* Not a classic class instance, try __unicode__ from type */

		/* _PyType_Lookup doesn't create a reference */

		func = _PyType_Lookup(Py_TYPE(v), unicodestr);

		if (func != NULL) {

			unicode_method_found = 1;

			res = PyObject_CallFunctionObjArgs(func, v, NULL);

		}

		else {

			PyErr_Clear();

		}

	}

	/* Didn't find __unicode__ */

	if (!unicode_method_found) {

		if (PyUnicode_Check(v)) {

			/* For a Unicode subtype that's didn't overwrite __unicode__,

			   return a true Unicode object with the same data. */

			return PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(v),

						     PyUnicode_GET_SIZE(v));

		}

		if (PyString_CheckExact(v)) {

			Py_INCREF(v);

			res = v;

		}

		else {

			if (Py_TYPE(v)->tp_str != NULL)

				res = (*Py_TYPE(v)->tp_str)(v);

			else

				res = PyObject_Repr(v);

		}

	}

	if (res == NULL)