Kill all uses and definitions of tp_print under Objects/. (Others will follow.)

Finally kill intobject.c, which was #ifdef'ed out a long time ago.

11 files changed, 11 insertions, 1470 deletions

diff --git a/Objects/boolobject.c b/Objects/boolobject.c
index 00d8515..3674086 100644
--- a/Objects/boolobject.c
+++ b/Objects/boolobject.c
@@ -3,15 +3,6 @@
 #include "Python.h"
 #include "longintrepr.h"
 
-/* We need to define bool_print to override int_print */
-
-static int
-bool_print(PyObject *self, FILE *fp, int flags)
-{
-	fputs(self == Py_False ? "False" : "True", fp);
-	return 0;
-}
-
 /* We define bool_repr to return "False" or "True" */
 
 static PyObject *false_str = NULL;
@@ -148,7 +139,7 @@ PyTypeObject PyBool_Type = {
 	sizeof(struct _longobject),
 	0,
 	0,					/* tp_dealloc */
-	bool_print,				/* tp_print */
+	0,					/* tp_print */
 	0,					/* tp_getattr */
 	0,					/* tp_setattr */
 	0,					/* tp_compare */
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index a51e806..253f714 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -327,16 +327,6 @@ complex_to_buf(char *buf, int bufsz, PyComplexObject *v, int precision)
 	}
 }
 
-static int
-complex_print(PyComplexObject *v, FILE *fp, int flags)
-{
-	char buf[100];
-	complex_to_buf(buf, sizeof(buf), v,
-		       (flags & Py_PRINT_RAW) ? PREC_STR : PREC_REPR);
-	fputs(buf, fp);
-	return 0;
-}
-
 static PyObject *
 complex_repr(PyComplexObject *v)
 {
@@ -1005,7 +995,7 @@ PyTypeObject PyComplex_Type = {
 	sizeof(PyComplexObject),
 	0,
 	complex_dealloc,			/* tp_dealloc */
-	(printfunc)complex_print,		/* tp_print */
+	0,					/* tp_print */
 	0,					/* tp_getattr */
 	0,					/* tp_setattr */
 	0,					/* tp_compare */
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 2a9c40c..1ae38d5 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -886,51 +886,6 @@ dict_dealloc(register dictobject *mp)
 	Py_TRASHCAN_SAFE_END(mp)
 }
 
-static int
-dict_print(register dictobject *mp, register FILE *fp, register int flags)
-{
-	register Py_ssize_t i;
-	register Py_ssize_t any;
-	int status;
-
-	status = Py_ReprEnter((PyObject*)mp);
-	if (status != 0) {
-		if (status < 0)
-			return status;
-		fprintf(fp, "{...}");
-		return 0;
-	}
-
-	fprintf(fp, "{");
-	any = 0;
-	for (i = 0; i <= mp->ma_mask; i++) {
-		dictentry *ep = mp->ma_table + i;
-		PyObject *pvalue = ep->me_value;
-		if (pvalue != NULL) {
-			/* Prevent PyObject_Repr from deleting value during
-			   key format */
-			Py_INCREF(pvalue);
-			if (any++ > 0)
-				fprintf(fp, ", ");
-			if (PyObject_Print((PyObject *)ep->me_key, fp, 0)!=0) {
-				Py_DECREF(pvalue);
-				Py_ReprLeave((PyObject*)mp);
-				return -1;
-			}
-			fprintf(fp, ": ");
-			if (PyObject_Print(pvalue, fp, 0) != 0) {
-				Py_DECREF(pvalue);
-				Py_ReprLeave((PyObject*)mp);
-				return -1;
-			}
-			Py_DECREF(pvalue);
-		}
-	}
-	fprintf(fp, "}");
-	Py_ReprLeave((PyObject*)mp);
-	return 0;
-}
-
 static PyObject *
 dict_repr(dictobject *mp)
 {
@@ -1974,7 +1929,7 @@ PyTypeObject PyDict_Type = {
 	sizeof(dictobject),
 	0,
 	(destructor)dict_dealloc,		/* tp_dealloc */
-	(printfunc)dict_print,			/* tp_print */
+	0,					/* tp_print */
 	0,					/* tp_getattr */
 	0,					/* tp_setattr */
 	0,					/* tp_compare */
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index bf65541..4260f50 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -205,7 +205,7 @@ format_double(char *buf, size_t buflen, double ob_fval, int precision)
 {
 	register char *cp;
 	char format[32];
-	/* Subroutine for float_repr, float_str, float_print and others.
+	/* Subroutine for float_repr, float_str, and others.
 	   We want float numbers to be recognizable as such,
 	   i.e., they should contain a decimal point or an exponent.
 	   However, %g may print the number as an integer;
@@ -286,17 +286,6 @@ convert_to_double(PyObject **v, double *dbl)
 #define PREC_REPR	17
 #define PREC_STR	12
 
-/* ARGSUSED */
-static int
-float_print(PyFloatObject *v, FILE *fp, int flags)
-{
-	char buf[100];
-	format_float(buf, sizeof(buf), v,
-		     (flags & Py_PRINT_RAW) ? PREC_STR : PREC_REPR);
-	fputs(buf, fp);
-	return 0;
-}
-
 static PyObject *
 float_repr(PyFloatObject *v)
 {
@@ -1058,7 +1047,7 @@ PyTypeObject PyFloat_Type = {
 	sizeof(PyFloatObject),
 	0,
 	(destructor)float_dealloc,		/* tp_dealloc */
-	(printfunc)float_print, 		/* tp_print */
+	0,			 		/* tp_print */
 	0,					/* tp_getattr */
 	0,					/* tp_setattr */
 	0,			 		/* tp_compare */
diff --git a/Objects/intobject.c b/Objects/intobject.c
deleted file mode 100644
index 9455f9e..0000000
--- a/Objects/intobject.c
+++ /dev/null
@@ -1,1226 +0,0 @@
-
-/* Integer object implementation */
-
-#include "Python.h"
-#include <ctype.h>
-
-long
-PyInt_GetMax(void)
-{
-	return LONG_MAX;	/* To initialize sys.maxint */
-}
-
-#if 0
-/* Integers are quite normal objects, to make object handling uniform.
-   (Using odd pointers to represent integers would save much space
-   but require extra checks for this special case throughout the code.)
-   Since a typical Python program spends much of its time allocating
-   and deallocating integers, these operations should be very fast.
-   Therefore we use a dedicated allocation scheme with a much lower
-   overhead (in space and time) than straight malloc(): a simple
-   dedicated free list, filled when necessary with memory from malloc().
-
-   block_list is a singly-linked list of all PyIntBlocks ever allocated,
-   linked via their next members.  PyIntBlocks are never returned to the
-   system before shutdown (PyInt_Fini).
-
-   free_list is a singly-linked list of available PyIntObjects, linked
-   via abuse of their ob_type members.
-*/
-
-#define BLOCK_SIZE	1000	/* 1K less typical malloc overhead */
-#define BHEAD_SIZE	8	/* Enough for a 64-bit pointer */
-#define N_INTOBJECTS	((BLOCK_SIZE - BHEAD_SIZE) / sizeof(PyIntObject))
-
-struct _intblock {
-	struct _intblock *next;
-	PyIntObject objects[N_INTOBJECTS];
-};
-
-typedef struct _intblock PyIntBlock;
-
-static PyIntBlock *block_list = NULL;
-static PyIntObject *free_list = NULL;
-
-static PyIntObject *
-fill_free_list(void)
-{
-	PyIntObject *p, *q;
-	/* Python's object allocator isn't appropriate for large blocks. */
-	p = (PyIntObject *) PyMem_MALLOC(sizeof(PyIntBlock));
-	if (p == NULL)
-		return (PyIntObject *) PyErr_NoMemory();
-	((PyIntBlock *)p)->next = block_list;
-	block_list = (PyIntBlock *)p;
-	/* Link the int objects together, from rear to front, then return
-	   the address of the last int object in the block. */
-	p = &((PyIntBlock *)p)->objects[0];
-	q = p + N_INTOBJECTS;
-	while (--q > p)
-		Py_Type(q) = (struct _typeobject *)(q-1);
-	Py_Type(q) = NULL;
-	return p + N_INTOBJECTS - 1;
-}
-
-#ifndef NSMALLPOSINTS
-#define NSMALLPOSINTS		257
-#endif
-#ifndef NSMALLNEGINTS
-#define NSMALLNEGINTS		5
-#endif
-#if NSMALLNEGINTS + NSMALLPOSINTS > 0
-/* References to small integers are saved in this array so that they
-   can be shared.
-   The integers that are saved are those in the range
-   -NSMALLNEGINTS (inclusive) to NSMALLPOSINTS (not inclusive).
-*/
-static PyIntObject *small_ints[NSMALLNEGINTS + NSMALLPOSINTS];
-#endif
-#ifdef COUNT_ALLOCS
-int quick_int_allocs, quick_neg_int_allocs;
-#endif
-
-PyObject *
-PyInt_FromLong(long ival)
-{
-	register PyIntObject *v;
-#if NSMALLNEGINTS + NSMALLPOSINTS > 0
-	if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) {
-		v = small_ints[ival + NSMALLNEGINTS];
-		Py_INCREF(v);
-#ifdef COUNT_ALLOCS
-		if (ival >= 0)
-			quick_int_allocs++;
-		else
-			quick_neg_int_allocs++;
-#endif
-		return (PyObject *) v;
-	}
-#endif
-	if (free_list == NULL) {
-		if ((free_list = fill_free_list()) == NULL)
-			return NULL;
-	}
-	/* Inline PyObject_New */
-	v = free_list;
-	free_list = (PyIntObject *)Py_Type(v);
-	PyObject_INIT(v, &PyInt_Type);
-	v->ob_ival = ival;
-	return (PyObject *) v;
-}
-
-PyObject *
-PyInt_FromSize_t(size_t ival)
-{
-	if (ival <= LONG_MAX)
-		return PyInt_FromLong((long)ival);
-	return _PyLong_FromSize_t(ival);
-}
-
-PyObject *
-PyInt_FromSsize_t(Py_ssize_t ival)
-{
-	if (ival >= LONG_MIN && ival <= LONG_MAX)
-		return PyInt_FromLong((long)ival);
-	return _PyLong_FromSsize_t(ival);
-}
-
-static void
-int_dealloc(PyIntObject *v)
-{
-	if (PyInt_CheckExact(v)) {
-		Py_Type(v) = (struct _typeobject *)free_list;
-		free_list = v;
-	}
-	else
-		Py_Type(v)->tp_free((PyObject *)v);
-}
-
-static void
-int_free(PyIntObject *v)
-{
-	Py_Type(v) = (struct _typeobject *)free_list;
-	free_list = v;
-}
-
-long
-PyInt_AsLong(register PyObject *op)
-{
-	PyNumberMethods *nb;
-	PyIntObject *io;
-	long val;
-
-	if (op && PyInt_Check(op))
-		return PyInt_AS_LONG((PyIntObject*) op);
-
-	if (op == NULL || (nb = Py_Type(op)->tp_as_number) == NULL ||
-	    nb->nb_int == NULL) {
-		PyErr_SetString(PyExc_TypeError, "an integer is required");
-		return -1;
-	}
-
-	io = (PyIntObject*) (*nb->nb_int) (op);
-	if (io == NULL)
-		return -1;
-	if (!PyInt_Check(io)) {
-		if (PyLong_Check(io)) {
-			/* got a long? => retry int conversion */
-			val = PyLong_AsLong((PyObject *)io);
-			Py_DECREF(io);
-			if ((val == -1) && PyErr_Occurred())
-				return -1;
-			return val;
-		}
-		else
-		{
-			Py_DECREF(io);
-			PyErr_SetString(PyExc_TypeError,
-					"nb_int should return int object");
-			return -1;
-		}
-	}
-
-	val = PyInt_AS_LONG(io);
-	Py_DECREF(io);
-
-	return val;
-}
-
-Py_ssize_t
-PyInt_AsSsize_t(register PyObject *op)
-{
-#if SIZEOF_SIZE_T != SIZEOF_LONG
-	PyNumberMethods *nb;
-	PyIntObject *io;
-	Py_ssize_t val;
-#endif
-
-	if (op == NULL) {
-		PyErr_SetString(PyExc_TypeError, "an integer is required");
-		return -1;
-	}
-
-	if (PyInt_Check(op))
-		return PyInt_AS_LONG((PyIntObject*) op);
-	if (PyLong_Check(op))
-		return _PyLong_AsSsize_t(op);
-#if SIZEOF_SIZE_T == SIZEOF_LONG
-	return PyInt_AsLong(op);
-#else
-
-	if ((nb = Py_Type(op)->tp_as_number) == NULL ||
-	    (nb->nb_int == NULL && nb->nb_long == 0)) {
-		PyErr_SetString(PyExc_TypeError, "an integer is required");
-		return -1;
-	}
-
-	if (nb->nb_long != 0)
-		io = (PyIntObject*) (*nb->nb_long) (op);
-	else
-		io = (PyIntObject*) (*nb->nb_int) (op);
-	if (io == NULL)
-		return -1;
-	if (!PyInt_Check(io)) {
-		if (PyLong_Check(io)) {
-			/* got a long? => retry int conversion */
-			val = _PyLong_AsSsize_t((PyObject *)io);
-			Py_DECREF(io);
-			if ((val == -1) && PyErr_Occurred())
-				return -1;
-			return val;
-		}
-		else
-		{
-			Py_DECREF(io);
-			PyErr_SetString(PyExc_TypeError,
-					"nb_int should return int object");
-			return -1;
-		}
-	}
-
-	val = PyInt_AS_LONG(io);
-	Py_DECREF(io);
-
-	return val;
-#endif
-}
-
-unsigned long
-PyInt_AsUnsignedLongMask(register PyObject *op)
-{
-	PyNumberMethods *nb;
-	PyIntObject *io;
-	unsigned long val;
-
-	if (op && PyInt_Check(op))
-		return PyInt_AS_LONG((PyIntObject*) op);
-	if (op && PyLong_Check(op))
-		return PyLong_AsUnsignedLongMask(op);
-
-	if (op == NULL || (nb = Py_Type(op)->tp_as_number) == NULL ||
-	    nb->nb_int == NULL) {
-		PyErr_SetString(PyExc_TypeError, "an integer is required");
-		return (unsigned long)-1;
-	}
-
-	io = (PyIntObject*) (*nb->nb_int) (op);
-	if (io == NULL)
-		return (unsigned long)-1;
-	if (!PyInt_Check(io)) {
-		if (PyLong_Check(io)) {
-			val = PyLong_AsUnsignedLongMask((PyObject *)io);
-			Py_DECREF(io);
-			if (PyErr_Occurred())
-				return (unsigned long)-1;
-			return val;
-		}
-		else
-		{
-			Py_DECREF(io);
-			PyErr_SetString(PyExc_TypeError,
-					"nb_int should return int object");
-			return (unsigned long)-1;
-		}
-	}
-
-	val = PyInt_AS_LONG(io);
-	Py_DECREF(io);
-
-	return val;
-}
-
-#ifdef HAVE_LONG_LONG
-unsigned PY_LONG_LONG
-PyInt_AsUnsignedLongLongMask(register PyObject *op)
-{
-	PyNumberMethods *nb;
-	PyIntObject *io;
-	unsigned PY_LONG_LONG val;
-
-	if (op && PyInt_Check(op))
-		return PyInt_AS_LONG((PyIntObject*) op);
-	if (op && PyLong_Check(op))
-		return PyLong_AsUnsignedLongLongMask(op);
-
-	if (op == NULL || (nb = Py_Type(op)->tp_as_number) == NULL ||
-	    nb->nb_int == NULL) {
-		PyErr_SetString(PyExc_TypeError, "an integer is required");
-		return (unsigned PY_LONG_LONG)-1;
-	}
-
-	io = (PyIntObject*) (*nb->nb_int) (op);
-	if (io == NULL)
-		return (unsigned PY_LONG_LONG)-1;
-	if (!PyInt_Check(io)) {
-		if (PyLong_Check(io)) {
-			val = PyLong_AsUnsignedLongLongMask((PyObject *)io);
-			Py_DECREF(io);
-			if (PyErr_Occurred())
-				return (unsigned PY_LONG_LONG)-1;
-			return val;
-		}
-		else
-		{
-			Py_DECREF(io);
-			PyErr_SetString(PyExc_TypeError,
-					"nb_int should return int object");
-			return (unsigned PY_LONG_LONG)-1;
-		}
-	}
-
-	val = PyInt_AS_LONG(io);
-	Py_DECREF(io);
-
-	return val;
-}
-#endif
-
-PyObject *
-PyInt_FromString(char *s, char **pend, int base)
-{
-	char *end;
-	long x;
-	Py_ssize_t slen;
-	PyObject *sobj, *srepr;
-
-	if ((base != 0 && base < 2) || base > 36) {
-		PyErr_SetString(PyExc_ValueError,
-				"int() base must be >= 2 and <= 36");
-		return NULL;
-	}
-
-	while (*s && isspace(Py_CHARMASK(*s)))
-		s++;
-	errno = 0;
-	if (base == 0 && s[0] == '0') {
-		x = (long) PyOS_strtoul(s, &end, base);
-		if (x < 0)
-			return PyLong_FromString(s, pend, base);
-	}
-	else
-		x = PyOS_strtol(s, &end, base);
-	if (end == s || !isalnum(Py_CHARMASK(end[-1])))
-		goto bad;
-	while (*end && isspace(Py_CHARMASK(*end)))
-		end++;
-	if (*end != '\0') {
-  bad:
-		slen = strlen(s) < 200 ? strlen(s) : 200;
-		sobj = PyString_FromStringAndSize(s, slen);
-		if (sobj == NULL)
-			return NULL;
-		srepr = PyObject_ReprStr8(sobj);
-		Py_DECREF(sobj);
-		if (srepr == NULL)
-			return NULL;
-		PyErr_Format(PyExc_ValueError,
-			     "invalid literal for int() with base %d: %s",
-			     base, PyString_AS_STRING(srepr));
-		Py_DECREF(srepr);
-		return NULL;
-	}
-	else if (errno != 0)
-		return PyLong_FromString(s, pend, base);
-	if (pend)
-		*pend = end;
-	return PyInt_FromLong(x);
-}
-
-PyObject *
-PyInt_FromUnicode(Py_UNICODE *s, Py_ssize_t length, int base)
-{
-	PyObject *result;
-	char *buffer = (char *)PyMem_MALLOC(length+1);
-
-	if (buffer == NULL)
-		return PyErr_NoMemory();
-
-	if (PyUnicode_EncodeDecimal(s, length, buffer, NULL)) {
-		PyMem_FREE(buffer);
-		return NULL;
-	}
-	result = PyInt_FromString(buffer, NULL, base);
-	PyMem_FREE(buffer);
-	return result;
-}
-
-/* Methods */
-
-/* Integers are seen as the "smallest" of all numeric types and thus
-   don't have any knowledge about conversion of other types to
-   integers. */
-
-#define CONVERT_TO_LONG(obj, lng)		\
-	if (PyInt_Check(obj)) {			\
-		lng = PyInt_AS_LONG(obj);	\
-	}					\
-	else {					\
-		Py_INCREF(Py_NotImplemented);	\
-		return Py_NotImplemented;	\
-	}
-
-/* ARGSUSED */
-static int
-int_print(PyIntObject *v, FILE *fp, int flags)
-     /* flags -- not used but required by interface */
-{
-	fprintf(fp, "%ld", v->ob_ival);
-	return 0;
-}
-
-static PyObject *
-int_repr(PyIntObject *v)
-{
-	return PyUnicode_FromFormat("%ld", v->ob_ival);
-}
-
-static int
-int_compare(PyIntObject *v, PyIntObject *w)
-{
-	register long i = v->ob_ival;
-	register long j = w->ob_ival;
-	return (i < j) ? -1 : (i > j) ? 1 : 0;
-}
-
-static PyObject *
-int_richcompare(PyObject *self, PyObject *other, int op)
-{
-	if (!PyInt_Check(self) || !PyInt_Check(other)) {
-		Py_INCREF(Py_NotImplemented);
-		return Py_NotImplemented;
-	}
-	return Py_CmpToRich(op, int_compare((PyIntObject *)self, 
-					    (PyIntObject *)other));
-}
-
-static long
-int_hash(PyIntObject *v)
-{
-	/* XXX If this is changed, you also need to change the way
-	   Python's long, float and complex types are hashed. */
-	long x = v -> ob_ival;
-	if (x == -1)
-		x = -2;
-	return x;
-}
-
-static PyObject *
-int_add(PyIntObject *v, PyIntObject *w)
-{
-	register long a, b, x;
-	CONVERT_TO_LONG(v, a);
-	CONVERT_TO_LONG(w, b);
-	x = a + b;
-	if ((x^a) >= 0 || (x^b) >= 0)
-		return PyInt_FromLong(x);
-	return PyLong_Type.tp_as_number->nb_add((PyObject *)v, (PyObject *)w);
-}
-
-static PyObject *
-int_sub(PyIntObject *v, PyIntObject *w)
-{
-	register long a, b, x;
-	CONVERT_TO_LONG(v, a);
-	CONVERT_TO_LONG(w, b);
-	x = a - b;
-	if ((x^a) >= 0 || (x^~b) >= 0)
-		return PyInt_FromLong(x);
-	return PyLong_Type.tp_as_number->nb_subtract((PyObject *)v,
-						     (PyObject *)w);
-}
-
-/*
-Integer overflow checking for * is painful:  Python tried a couple ways, but
-they didn't work on all platforms, or failed in endcases (a product of
--sys.maxint-1 has been a particular pain).
-
-Here's another way:
-
-The native long product x*y is either exactly right or *way* off, being
-just the last n bits of the true product, where n is the number of bits
-in a long (the delivered product is the true product plus i*2**n for
-some integer i).
-
-The native double product (double)x * (double)y is subject to three
-rounding errors:  on a sizeof(long)==8 box, each cast to double can lose
-info, and even on a sizeof(long)==4 box, the multiplication can lose info.
-But, unlike the native long product, it's not in *range* trouble:  even
-if sizeof(long)==32 (256-bit longs), the product easily fits in the
-dynamic range of a double.  So the leading 50 (or so) bits of the double
-product are correct.
-
-We check these two ways against each other, and declare victory if they're
-approximately the same.  Else, because the native long product is the only
-one that can lose catastrophic amounts of information, it's the native long
-product that must have overflowed.
-*/
-
-static PyObject *
-int_mul(PyObject *v, PyObject *w)
-{
-	long a, b;
-	long longprod;			/* a*b in native long arithmetic */
-	double doubled_longprod;	/* (double)longprod */
-	double doubleprod;		/* (double)a * (double)b */
-
-	CONVERT_TO_LONG(v, a);
-	CONVERT_TO_LONG(w, b);
-	longprod = a * b;
-	doubleprod = (double)a * (double)b;
-	doubled_longprod = (double)longprod;
-
-	/* Fast path for normal case:  small multiplicands, and no info
-	   is lost in either method. */
-	if (doubled_longprod == doubleprod)
-		return PyInt_FromLong(longprod);
-
-	/* Somebody somewhere lost info.  Close enough, or way off?  Note
-	   that a != 0 and b != 0 (else doubled_longprod == doubleprod == 0).
-	   The difference either is or isn't significant compared to the
-	   true value (of which doubleprod is a good approximation).
-	*/
-	{
-		const double diff = doubled_longprod - doubleprod;
-		const double absdiff = diff >= 0.0 ? diff : -diff;
-		const double absprod = doubleprod >= 0.0 ? doubleprod :
-							  -doubleprod;
-		/* absdiff/absprod <= 1/32 iff
-		   32 * absdiff <= absprod -- 5 good bits is "close enough" */
-		if (32.0 * absdiff <= absprod)
-			return PyInt_FromLong(longprod);
-		else
-			return PyLong_Type.tp_as_number->nb_multiply(v, w);
-	}
-}
-
-/* Integer overflow checking for unary negation: on a 2's-complement
- * box, -x overflows iff x is the most negative long.  In this case we
- * get -x == x.  However, -x is undefined (by C) if x /is/ the most
- * negative long (it's a signed overflow case), and some compilers care.
- * So we cast x to unsigned long first.  However, then other compilers
- * warn about applying unary minus to an unsigned operand.  Hence the
- * weird "0-".
- */
-#define UNARY_NEG_WOULD_OVERFLOW(x)	\
-	((x) < 0 && (unsigned long)(x) == 0-(unsigned long)(x))
-
-/* Return type of i_divmod */
-enum divmod_result {
-	DIVMOD_OK,		/* Correct result */
-	DIVMOD_OVERFLOW,	/* Overflow, try again using longs */
-	DIVMOD_ERROR		/* Exception raised */
-};
-
-static enum divmod_result
-i_divmod(register long x, register long y,
-         long *p_xdivy, long *p_xmody)
-{
-	long xdivy, xmody;
-
-	if (y == 0) {
-		PyErr_SetString(PyExc_ZeroDivisionError,
-				"integer division or modulo by zero");
-		return DIVMOD_ERROR;
-	}
-	/* (-sys.maxint-1)/-1 is the only overflow case. */
-	if (y == -1 && UNARY_NEG_WOULD_OVERFLOW(x))
-		return DIVMOD_OVERFLOW;
-	xdivy = x / y;
-	xmody = x - xdivy * y;
-	/* If the signs of x and y differ, and the remainder is non-0,
-	 * C89 doesn't define whether xdivy is now the floor or the
-	 * ceiling of the infinitely precise quotient.  We want the floor,
-	 * and we have it iff the remainder's sign matches y's.
-	 */
-	if (xmody && ((y ^ xmody) < 0) /* i.e. and signs differ */) {
-		xmody += y;
-		--xdivy;
-		assert(xmody && ((y ^ xmody) >= 0));
-	}
-	*p_xdivy = xdivy;
-	*p_xmody = xmody;
-	return DIVMOD_OK;
-}
-
-static PyObject *
-int_floor_div(PyIntObject *x, PyIntObject *y)
-{
-	long xi, yi;
-	long d, m;
-	CONVERT_TO_LONG(x, xi);
-	CONVERT_TO_LONG(y, yi);
-	switch (i_divmod(xi, yi, &d, &m)) {
-	case DIVMOD_OK:
-		return PyInt_FromLong(d);
-	case DIVMOD_OVERFLOW:
-		return PyLong_Type.tp_as_number->nb_floor_divide((PyObject *)x,
-							         (PyObject *)y);
-	default:
-		return NULL;
-	}
-}
-
-static PyObject *
-int_true_divide(PyObject *v, PyObject *w)
-{
-	/* If they aren't both ints, give someone else a chance.  In
-	   particular, this lets int/long get handled by longs, which
-	   underflows to 0 gracefully if the long is too big to convert
-	   to float. */
-	if (PyInt_Check(v) && PyInt_Check(w))
-		return PyFloat_Type.tp_as_number->nb_true_divide(v, w);
-	Py_INCREF(Py_NotImplemented);
-	return Py_NotImplemented;
-}
-
-static PyObject *
-int_mod(PyIntObject *x, PyIntObject *y)
-{
-	long xi, yi;
-	long d, m;
-	CONVERT_TO_LONG(x, xi);
-	CONVERT_TO_LONG(y, yi);
-	switch (i_divmod(xi, yi, &d, &m)) {
-	case DIVMOD_OK:
-		return PyInt_FromLong(m);
-	case DIVMOD_OVERFLOW:
-		return PyLong_Type.tp_as_number->nb_remainder((PyObject *)x,
-							      (PyObject *)y);
-	default:
-		return NULL;
-	}
-}
-
-static PyObject *
-int_divmod(PyIntObject *x, PyIntObject *y)
-{
-	long xi, yi;
-	long d, m;
-	CONVERT_TO_LONG(x, xi);
-	CONVERT_TO_LONG(y, yi);
-	switch (i_divmod(xi, yi, &d, &m)) {
-	case DIVMOD_OK:
-		return Py_BuildValue("(ll)", d, m);
-	case DIVMOD_OVERFLOW:
-		return PyLong_Type.tp_as_number->nb_divmod((PyObject *)x,
-							   (PyObject *)y);
-	default:
-		return NULL;
-	}
-}
-
-static PyObject *
-int_pow(PyIntObject *v, PyIntObject *w, PyIntObject *z)
-{
-	register long iv, iw, iz=0, ix, temp, prev;
-	CONVERT_TO_LONG(v, iv);
-	CONVERT_TO_LONG(w, iw);
-	if (iw < 0) {
-		if ((PyObject *)z != Py_None) {
-			PyErr_SetString(PyExc_TypeError, "pow() 2nd argument "
-			     "cannot be negative when 3rd argument specified");
-			return NULL;
-		}
-		/* Return a float.  This works because we know that
-		   this calls float_pow() which converts its
-		   arguments to double. */
-		return PyFloat_Type.tp_as_number->nb_power(
-			(PyObject *)v, (PyObject *)w, (PyObject *)z);
-	}
- 	if ((PyObject *)z != Py_None) {
-		CONVERT_TO_LONG(z, iz);
-		if (iz == 0) {
-			PyErr_SetString(PyExc_ValueError,
-					"pow() 3rd argument cannot be 0");
-			return NULL;
-		}
-	}
-	/*
-	 * XXX: The original exponentiation code stopped looping
-	 * when temp hit zero; this code will continue onwards
-	 * unnecessarily, but at least it won't cause any errors.
-	 * Hopefully the speed improvement from the fast exponentiation
-	 * will compensate for the slight inefficiency.
-	 * XXX: Better handling of overflows is desperately needed.
-	 */
- 	temp = iv;
-	ix = 1;
-	while (iw > 0) {
-	 	prev = ix;	/* Save value for overflow check */
-	 	if (iw & 1) {
-		 	ix = ix*temp;
-			if (temp == 0)
-				break; /* Avoid ix / 0 */
-			if (ix / temp != prev) {
-				return PyLong_Type.tp_as_number->nb_power(
-					(PyObject *)v,
-					(PyObject *)w,
-					(PyObject *)z);
-			}
-		}
-	 	iw >>= 1;	/* Shift exponent down by 1 bit */
-	        if (iw==0) break;
-	 	prev = temp;
-	 	temp *= temp;	/* Square the value of temp */
-	 	if (prev != 0 && temp / prev != prev) {
-			return PyLong_Type.tp_as_number->nb_power(
-				(PyObject *)v, (PyObject *)w, (PyObject *)z);
-		}
-	 	if (iz) {
-			/* If we did a multiplication, perform a modulo */
-		 	ix = ix % iz;
-		 	temp = temp % iz;
-		}
-	}
-	if (iz) {
-	 	long div, mod;
-		switch (i_divmod(ix, iz, &div, &mod)) {
-		case DIVMOD_OK:
-			ix = mod;
-			break;
-		case DIVMOD_OVERFLOW:
-			return PyLong_Type.tp_as_number->nb_power(
-				(PyObject *)v, (PyObject *)w, (PyObject *)z);
-		default:
-			return NULL;
-		}
-	}
-	return PyInt_FromLong(ix);
-}
-
-static PyObject *
-int_neg(PyIntObject *v)
-{
-	register long a;
-	a = v->ob_ival;
-        /* check for overflow */
-	if (UNARY_NEG_WOULD_OVERFLOW(a)) {
-		PyObject *o = PyLong_FromLong(a);
-		if (o != NULL) {
-			PyObject *result = PyNumber_Negative(o);
-			Py_DECREF(o);
-			return result;
-		}
-		return NULL;
-	}
-	return PyInt_FromLong(-a);
-}
-
-static PyObject *
-int_pos(PyIntObject *v)
-{
-	if (PyInt_CheckExact(v)) {
-		Py_INCREF(v);
-		return (PyObject *)v;
-	}
-	else
-		return PyInt_FromLong(v->ob_ival);
-}
-
-static PyObject *
-int_abs(PyIntObject *v)
-{
-	if (v->ob_ival >= 0)
-		return int_pos(v);
-	else
-		return int_neg(v);
-}
-
-static int
-int_bool(PyIntObject *v)
-{
-	return v->ob_ival != 0;
-}
-
-static PyObject *
-int_invert(PyIntObject *v)
-{
-	return PyInt_FromLong(~v->ob_ival);
-}
-
-static PyObject *
-int_lshift(PyIntObject *v, PyIntObject *w)
-{
-	long a, b, c;
-	PyObject *vv, *ww, *result;
-
-	CONVERT_TO_LONG(v, a);
-	CONVERT_TO_LONG(w, b);
-	if (b < 0) {
-		PyErr_SetString(PyExc_ValueError, "negative shift count");
-		return NULL;
-	}
-	if (a == 0 || b == 0)
-		return int_pos(v);
-	if (b >= LONG_BIT) {
-		vv = PyLong_FromLong(PyInt_AS_LONG(v));
-		if (vv == NULL)
-			return NULL;
-		ww = PyLong_FromLong(PyInt_AS_LONG(w));
-		if (ww == NULL) {
-			Py_DECREF(vv);
-			return NULL;
-		}
-		result = PyNumber_Lshift(vv, ww);
-		Py_DECREF(vv);
-		Py_DECREF(ww);
-		return result;
-	}
-	c = a << b;
-	if (a != Py_ARITHMETIC_RIGHT_SHIFT(long, c, b)) {
-		vv = PyLong_FromLong(PyInt_AS_LONG(v));
-		if (vv == NULL)
-			return NULL;
-		ww = PyLong_FromLong(PyInt_AS_LONG(w));
-		if (ww == NULL) {
-			Py_DECREF(vv);
-			return NULL;
-		}
-		result = PyNumber_Lshift(vv, ww);
-		Py_DECREF(vv);
-		Py_DECREF(ww);
-		return result;
-	}
-	return PyInt_FromLong(c);
-}
-
-static PyObject *
-int_rshift(PyIntObject *v, PyIntObject *w)
-{
-	register long a, b;
-	CONVERT_TO_LONG(v, a);
-	CONVERT_TO_LONG(w, b);
-	if (b < 0) {
-		PyErr_SetString(PyExc_ValueError, "negative shift count");
-		return NULL;
-	}
-	if (a == 0 || b == 0)
-		return int_pos(v);
-	if (b >= LONG_BIT) {
-		if (a < 0)
-			a = -1;
-		else
-			a = 0;
-	}
-	else {
-		a = Py_ARITHMETIC_RIGHT_SHIFT(long, a, b);
-	}
-	return PyInt_FromLong(a);
-}
-
-static PyObject *
-int_and(PyIntObject *v, PyIntObject *w)
-{
-	register long a, b;
-	CONVERT_TO_LONG(v, a);
-	CONVERT_TO_LONG(w, b);
-	return PyInt_FromLong(a & b);
-}
-
-static PyObject *
-int_xor(PyIntObject *v, PyIntObject *w)
-{
-	register long a, b;
-	CONVERT_TO_LONG(v, a);
-	CONVERT_TO_LONG(w, b);
-	return PyInt_FromLong(a ^ b);
-}
-
-static PyObject *
-int_or(PyIntObject *v, PyIntObject *w)
-{
-	register long a, b;
-	CONVERT_TO_LONG(v, a);
-	CONVERT_TO_LONG(w, b);
-	return PyInt_FromLong(a | b);
-}
-
-static PyObject *
-int_int(PyIntObject *v)
-{
-	if (PyInt_CheckExact(v))
-		Py_INCREF(v);
-	else
-		v = (PyIntObject *)PyInt_FromLong(v->ob_ival);
-	return (PyObject *)v;
-}
-
-static PyObject *
-int_long(PyIntObject *v)
-{
-	return PyLong_FromLong((v -> ob_ival));
-}
-
-static PyObject *
-int_float(PyIntObject *v)
-{
-	return PyFloat_FromDouble((double)(v -> ob_ival));
-}
-
-static PyObject *
-int_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
-
-static PyObject *
-int_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-	PyObject *x = NULL;
-	int base = -909;
-	static char *kwlist[] = {"x", "base", 0};
-
-	if (type != &PyInt_Type)
-		return int_subtype_new(type, args, kwds); /* Wimp out */
-	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:int", kwlist,
-					 &x, &base))
-		return NULL;
-	if (x == NULL)
-		return PyInt_FromLong(0L);
-	if (base == -909)
-		return PyNumber_Int(x);
-	if (PyString_Check(x)) {
-		/* Since PyInt_FromString doesn't have a length parameter,
-		 * check here for possible NULs in the string. */
-		char *string = PyString_AS_STRING(x);
-		if (strlen(string) != PyString_Size(x)) {
-			/* create a repr() of the input string,
-			 * just like PyInt_FromString does */
-			PyObject *srepr;
-			srepr = PyObject_ReprStr8(x);
-			if (srepr == NULL)
-				return NULL;
-			PyErr_Format(PyExc_ValueError,
-			     "invalid literal for int() with base %d: %s",
-			     base, PyString_AS_STRING(srepr));
-			Py_DECREF(srepr);
-			return NULL;
-		}
-		return PyInt_FromString(string, NULL, base);
-	}
-	if (PyUnicode_Check(x))
-		return PyInt_FromUnicode(PyUnicode_AS_UNICODE(x),
-					 PyUnicode_GET_SIZE(x),
-					 base);
-	PyErr_SetString(PyExc_TypeError,
-			"int() can't convert non-string with explicit base");
-	return NULL;
-}
-
-/* Wimpy, slow approach to tp_new calls for subtypes of int:
-   first create a regular int from whatever arguments we got,
-   then allocate a subtype instance and initialize its ob_ival
-   from the regular int.  The regular int is then thrown away.
-*/
-static PyObject *
-int_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
-{
-	PyObject *tmp, *newobj;
-	long ival;
-
-	assert(PyType_IsSubtype(type, &PyInt_Type));
-	tmp = int_new(&PyInt_Type, args, kwds);
-	if (tmp == NULL)
-		return NULL;
-	if (!PyInt_Check(tmp)) {
-		ival = PyLong_AsLong(tmp);
-		if (ival == -1 && PyErr_Occurred()) {
-			Py_DECREF(tmp);
-			return NULL;
-		}
-	} else {
-		ival = ((PyIntObject *)tmp)->ob_ival;
-	}
-
-	newobj = type->tp_alloc(type, 0);
-	if (newobj == NULL) {
-		Py_DECREF(tmp);
-		return NULL;
-	}
-	((PyIntObject *)newobj)->ob_ival = ival;
-	Py_DECREF(tmp);
-	return newobj;
-}
-
-static PyObject *
-int_getnewargs(PyIntObject *v)
-{
-	return Py_BuildValue("(l)", v->ob_ival);
-}
-
-static PyMethodDef int_methods[] = {
-	{"__getnewargs__",	(PyCFunction)int_getnewargs,	METH_NOARGS},
-	{NULL,		NULL}		/* sentinel */
-};
-
-PyDoc_STRVAR(int_doc,
-"int(x[, base]) -> integer\n\
-\n\
-Convert a string or number to an integer, if possible.  A floating point\n\
-argument will be truncated towards zero (this does not include a string\n\
-representation of a floating point number!)  When converting a string, use\n\
-the optional base.  It is an error to supply a base when converting a\n\
-non-string.  If base is zero, the proper base is guessed based on the\n\
-string content.  If the argument is outside the integer range a\n\
-long object will be returned instead.");
-
-static PyNumberMethods int_as_number = {
-	(binaryfunc)int_add,	/*nb_add*/
-	(binaryfunc)int_sub,	/*nb_subtract*/
-	(binaryfunc)int_mul,	/*nb_multiply*/
-	(binaryfunc)int_mod,	/*nb_remainder*/
-	(binaryfunc)int_divmod,	/*nb_divmod*/
-	(ternaryfunc)int_pow,	/*nb_power*/
-	(unaryfunc)int_neg,	/*nb_negative*/
-	(unaryfunc)int_pos,	/*nb_positive*/
-	(unaryfunc)int_abs,	/*nb_absolute*/
-	(inquiry)int_bool,	/*nb_bool*/
-	(unaryfunc)int_invert,	/*nb_invert*/
-	(binaryfunc)int_lshift,	/*nb_lshift*/
-	(binaryfunc)int_rshift,	/*nb_rshift*/
-	(binaryfunc)int_and,	/*nb_and*/
-	(binaryfunc)int_xor,	/*nb_xor*/
-	(binaryfunc)int_or,	/*nb_or*/
-	0,			/*nb_coerce*/
-	(unaryfunc)int_int,	/*nb_int*/
-	(unaryfunc)int_long,	/*nb_long*/
-	(unaryfunc)int_float,	/*nb_float*/
-	0,			/*nb_oct*/ /* not in use */
-	0, 			/*nb_hex*/ /* not in use */
-	0,			/*nb_inplace_add*/
-	0,			/*nb_inplace_subtract*/
-	0,			/*nb_inplace_multiply*/
-	0,			/*nb_inplace_remainder*/
-	0,			/*nb_inplace_power*/
-	0,			/*nb_inplace_lshift*/
-	0,			/*nb_inplace_rshift*/
-	0,			/*nb_inplace_and*/
-	0,			/*nb_inplace_xor*/
-	0,			/*nb_inplace_or*/
-	(binaryfunc)int_floor_div,	/* nb_floor_divide */
-	int_true_divide,	/* nb_true_divide */
-	0,			/* nb_inplace_floor_divide */
-	0,			/* nb_inplace_true_divide */
-	(unaryfunc)int_int,	/* nb_index */
-};
-
-PyTypeObject PyInt_Type = {
-	PyVarObject_HEAD_INIT(&PyType_Type, 0)
-	"int",
-	sizeof(PyIntObject),
-	0,
-	(destructor)int_dealloc,		/* tp_dealloc */
-	(printfunc)int_print,			/* tp_print */
-	0,					/* tp_getattr */
-	0,					/* tp_setattr */
-	0,					/* tp_compare */
-	(reprfunc)int_repr,			/* tp_repr */
-	&int_as_number,				/* tp_as_number */
-	0,					/* tp_as_sequence */
-	0,					/* tp_as_mapping */
-	(hashfunc)int_hash,			/* tp_hash */
-        0,					/* tp_call */
-        (reprfunc)int_repr,			/* tp_str */
-	PyObject_GenericGetAttr,		/* tp_getattro */
-	0,					/* tp_setattro */
-	0,					/* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |
-		Py_TPFLAGS_INT_SUBCLASS,	/* tp_flags */
-	int_doc,				/* tp_doc */
-	0,					/* tp_traverse */
-	0,					/* tp_clear */
-	int_richcompare,			/* tp_richcompare */
-	0,					/* tp_weaklistoffset */
-	0,					/* tp_iter */
-	0,					/* tp_iternext */
-	int_methods,				/* tp_methods */
-	0,					/* tp_members */
-	0,					/* tp_getset */
-	0,					/* tp_base */
-	0,					/* tp_dict */
-	0,					/* tp_descr_get */
-	0,					/* tp_descr_set */
-	0,					/* tp_dictoffset */
-	0,					/* tp_init */
-	0,					/* tp_alloc */
-	int_new,				/* tp_new */
-	(freefunc)int_free,           		/* tp_free */
-};
-
-int
-_PyInt_Init(void)
-{
-	PyIntObject *v;
-	int ival;
-#if NSMALLNEGINTS + NSMALLPOSINTS > 0
-	for (ival = -NSMALLNEGINTS; ival < NSMALLPOSINTS; ival++) {
-              if (!free_list && (free_list = fill_free_list()) == NULL)
-			return 0;
-		/* PyObject_New is inlined */
-		v = free_list;
-		free_list = (PyIntObject *)Py_Type(v);
-		PyObject_INIT(v, &PyInt_Type);
-		v->ob_ival = ival;
-		small_ints[ival + NSMALLNEGINTS] = v;
-	}
-#endif
-	return 1;
-}
-
-void
-PyInt_Fini(void)
-{
-	PyIntObject *p;
-	PyIntBlock *list, *next;
-	int i;
-	unsigned int ctr;
-	int bc, bf;	/* block count, number of freed blocks */
-	int irem, isum;	/* remaining unfreed ints per block, total */
-
-#if NSMALLNEGINTS + NSMALLPOSINTS > 0
-        PyIntObject **q;
-
-        i = NSMALLNEGINTS + NSMALLPOSINTS;
-        q = small_ints;
-        while (--i >= 0) {
-                Py_XDECREF(*q);
-                *q++ = NULL;
-        }
-#endif
-	bc = 0;
-	bf = 0;
-	isum = 0;
-	list = block_list;
-	block_list = NULL;
-	free_list = NULL;
-	while (list != NULL) {
-		bc++;
-		irem = 0;
-		for (ctr = 0, p = &list->objects[0];
-		     ctr < N_INTOBJECTS;
-		     ctr++, p++) {
-			if (PyInt_CheckExact(p) && p->ob_refcnt != 0)
-				irem++;
-		}
-		next = list->next;
-		if (irem) {
-			list->next = block_list;
-			block_list = list;
-			for (ctr = 0, p = &list->objects[0];
-			     ctr < N_INTOBJECTS;
-			     ctr++, p++) {
-				if (!PyInt_CheckExact(p) ||
-				    p->ob_refcnt == 0) {
-					Py_Type(p) = (struct _typeobject *)
-						free_list;
-					free_list = p;
-				}
-#if NSMALLNEGINTS + NSMALLPOSINTS > 0
-				else if (-NSMALLNEGINTS <= p->ob_ival &&
-					 p->ob_ival < NSMALLPOSINTS &&
-					 small_ints[p->ob_ival +
-						    NSMALLNEGINTS] == NULL) {
-					Py_INCREF(p);
-					small_ints[p->ob_ival +
-						   NSMALLNEGINTS] = p;
-				}
-#endif
-			}
-		}
-		else {
-			PyMem_FREE(list);
-			bf++;
-		}
-		isum += irem;
-		list = next;
-	}
-	if (!Py_VerboseFlag)
-		return;
-	fprintf(stderr, "# cleanup ints");
-	if (!isum) {
-		fprintf(stderr, "\n");
-	}
-	else {
-		fprintf(stderr,
-			": %d unfreed int%s in %d out of %d block%s\n",
-			isum, isum == 1 ? "" : "s",
-			bc - bf, bc, bc == 1 ? "" : "s");
-	}
-	if (Py_VerboseFlag > 1) {
-		list = block_list;
-		while (list != NULL) {
-			for (ctr = 0, p = &list->objects[0];
-			     ctr < N_INTOBJECTS;
-			     ctr++, p++) {
-				if (PyInt_CheckExact(p) && p->ob_refcnt != 0)
-					/* XXX(twouters) cast refcount to
-					   long until %zd is universally
-					   available
-					 */
-					fprintf(stderr,
-				"#   <int at %p, refcnt=%ld, val=%ld>\n",
-						p, (long)p->ob_refcnt,
-						p->ob_ival);
-			}
-			list = list->next;
-		}
-	}
-}
-#endif /* if 0 */
diff --git a/Objects/listobject.c b/Objects/listobject.c
index 4d4399c..7e2483e 100644
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -272,33 +272,6 @@ list_dealloc(PyListObject *op)
 	Py_TRASHCAN_SAFE_END(op)
 }
 
-static int
-list_print(PyListObject *op, FILE *fp, int flags)
-{
-	int rc;
-	Py_ssize_t i;
-
-	rc = Py_ReprEnter((PyObject*)op);
-	if (rc != 0) {
-		if (rc < 0)
-			return rc;
-		fprintf(fp, "[...]");
-		return 0;
-	}
-	fprintf(fp, "[");
-	for (i = 0; i < Py_Size(op); i++) {
-		if (i > 0)
-			fprintf(fp, ", ");
-		if (PyObject_Print(op->ob_item[i], fp, 0) != 0) {
-			Py_ReprLeave((PyObject *)op);
-			return -1;
-		}
-	}
-	fprintf(fp, "]");
-	Py_ReprLeave((PyObject *)op);
-	return 0;
-}
-
 static PyObject *
 list_repr(PyListObject *v)
 {
@@ -2665,7 +2638,7 @@ PyTypeObject PyList_Type = {
 	sizeof(PyListObject),
 	0,
 	(destructor)list_dealloc,		/* tp_dealloc */
-	(printfunc)list_print,			/* tp_print */
+	0,					/* tp_print */
 	0,					/* tp_getattr */
 	0,					/* tp_setattr */
 	0,					/* tp_compare */
diff --git a/Objects/object.c b/Objects/object.c
index a725022..3eaf6fa 100644
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -279,7 +279,7 @@ internal_print(PyObject *op, FILE *fp, int flags, int nesting)
 			   universally available */
 			fprintf(fp, "<refcnt %ld at %p>",
 				(long)op->ob_refcnt, op);
-		else if (Py_Type(op)->tp_print == NULL) {
+		else {
 			PyObject *s;
 			if (flags & Py_PRINT_RAW)
 				s = PyObject_Str(op);
@@ -293,8 +293,6 @@ internal_print(PyObject *op, FILE *fp, int flags, int nesting)
 			}
 			Py_XDECREF(s);
 		}
-		else
-			ret = (*Py_Type(op)->tp_print)(op, fp, flags);
 	}
 	if (ret == 0) {
 		if (ferror(fp)) {
diff --git a/Objects/setobject.c b/Objects/setobject.c
index a5366c8..14d9155 100644
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -565,50 +565,6 @@ set_dealloc(PySetObject *so)
 	Py_TRASHCAN_SAFE_END(so)
 }
 
-static int
-set_tp_print(PySetObject *so, FILE *fp, int flags)
-{
-	setentry *entry;
-	Py_ssize_t pos=0;
-	char *emit = "";	/* No separator emitted on first pass */
-	char *separator = ", ";
-	int literalform = 0;
-	int status = Py_ReprEnter((PyObject*)so);
-
-	if (status != 0) {
-		if (status < 0)
-			return status;
-		fprintf(fp, "%s(...)", Py_Type(so)->tp_name);
-		return 0;
-	}        
-
-	if (!so->used) {
-		Py_ReprLeave((PyObject*)so);
-		fprintf(fp, "%s()", Py_Type(so)->tp_name);
-		return 0;
-	}
-
-	if (Py_Type(so) == &PySet_Type) {
-		literalform = 1;
-		fprintf(fp, "{");
-	} else
-		fprintf(fp, "%s([", Py_Type(so)->tp_name);
-	while (set_next(so, &pos, &entry)) {
-		fputs(emit, fp);
-		emit = separator;
-		if (PyObject_Print(entry->key, fp, 0) != 0) {
-			Py_ReprLeave((PyObject*)so);
-			return -1;
-		}
-	}
-	if (literalform)
-		fputs("}", fp);
-	else
-		fputs("])", fp);
-	Py_ReprLeave((PyObject*)so);
-	return 0;
-}
-
 static PyObject *
 set_repr(PySetObject *so)
 {
@@ -1957,7 +1913,7 @@ PyTypeObject PySet_Type = {
 	0,				/* tp_itemsize */
 	/* methods */
 	(destructor)set_dealloc,	/* tp_dealloc */
-	(printfunc)set_tp_print,	/* tp_print */
+	0,				/* tp_print */
 	0,				/* tp_getattr */
 	0,				/* tp_setattr */
 	set_nocmp,			/* tp_compare */
@@ -2050,7 +2006,7 @@ PyTypeObject PyFrozenSet_Type = {
 	0,				/* tp_itemsize */
 	/* methods */
 	(destructor)set_dealloc,	/* tp_dealloc */
-	(printfunc)set_tp_print,	/* tp_print */
+	0,				/* tp_print */
 	0,				/* tp_getattr */
 	0,				/* tp_setattr */
 	set_nocmp,			/* tp_compare */
diff --git a/Objects/stringobject.c b/Objects/stringobject.c
index 6b03047..7a35974 100644
--- a/Objects/stringobject.c
+++ b/Objects/stringobject.c
@@ -764,71 +764,6 @@ PyString_AsStringAndSize(register PyObject *obj,
 #include "stringlib/partition.h"
 
 
-static int
-string_print(PyStringObject *op, FILE *fp, int flags)
-{
-	Py_ssize_t i;
-	char c;
-	int quote;
-
-	/* XXX Ought to check for interrupts when writing long strings */
-	if (! PyString_CheckExact(op)) {
-		int ret;
-		/* A str subclass may have its own __str__ method. */
-		op = (PyStringObject *) PyObject_Str((PyObject *)op);
-		if (op == NULL)
-			return -1;
-		ret = string_print(op, fp, flags);
-		Py_DECREF(op);
-		return ret;
-	}
-	if (flags & Py_PRINT_RAW) {
-		char *data = op->ob_sval;
-		Py_ssize_t size = Py_Size(op);
-		while (size > INT_MAX) {
-			/* Very long strings cannot be written atomically.
-			 * But don't write exactly INT_MAX bytes at a time
-			 * to avoid memory aligment issues.
-			 */
-			const int chunk_size = INT_MAX & ~0x3FFF;
-			fwrite(data, 1, chunk_size, fp);
-			data += chunk_size;
-			size -= chunk_size;
-		}
-#ifdef __VMS
-                if (size) fwrite(data, (int)size, 1, fp);
-#else
-                fwrite(data, 1, (int)size, fp);
-#endif
-		return 0;
-	}
-
-	/* figure out which quote to use; single is preferred */
-	quote = '\'';
-	if (memchr(op->ob_sval, '\'', Py_Size(op)) &&
-	    !memchr(op->ob_sval, '"', Py_Size(op)))
-		quote = '"';
-
-	fputc(quote, fp);
-	for (i = 0; i < Py_Size(op); i++) {
-		c = op->ob_sval[i];
-		if (c == quote || c == '\\')
-			fprintf(fp, "\\%c", c);
-                else if (c == '\t')
-                        fprintf(fp, "\\t");
-                else if (c == '\n')
-                        fprintf(fp, "\\n");
-                else if (c == '\r')
-                        fprintf(fp, "\\r");
-		else if (c < ' ' || c >= 0x7f)
-			fprintf(fp, "\\x%02x", c & 0xff);
-		else
-			fputc(c, fp);
-	}
-	fputc(quote, fp);
-	return 0;
-}
-
 PyObject *
 PyString_Repr(PyObject *obj, int smartquotes)
 {
@@ -3983,7 +3918,7 @@ PyTypeObject PyString_Type = {
 	sizeof(PyStringObject),
 	sizeof(char),
  	string_dealloc, 			/* tp_dealloc */
-	(printfunc)string_print, 		/* tp_print */
+	0,			 		/* tp_print */
 	0,					/* tp_getattr */
 	0,					/* tp_setattr */
 	0,					/* tp_compare */
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index 6e30c81..3c5dfb5 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -184,23 +184,6 @@ done:
 	Py_TRASHCAN_SAFE_END(op)
 }
 
-static int
-tupleprint(PyTupleObject *op, FILE *fp, int flags)
-{
-	Py_ssize_t i;
-	fprintf(fp, "(");
-	for (i = 0; i < Py_Size(op); i++) {
-		if (i > 0)
-			fprintf(fp, ", ");
-		if (PyObject_Print(op->ob_item[i], fp, 0) != 0)
-			return -1;
-	}
-	if (Py_Size(op) == 1)
-		fprintf(fp, ",");
-	fprintf(fp, ")");
-	return 0;
-}
-
 static PyObject *
 tuplerepr(PyTupleObject *v)
 {
@@ -653,7 +636,7 @@ PyTypeObject PyTuple_Type = {
 	sizeof(PyTupleObject) - sizeof(PyObject *),
 	sizeof(PyObject *),
 	(destructor)tupledealloc,		/* tp_dealloc */
-	(printfunc)tupleprint,			/* tp_print */
+	0,					/* tp_print */
 	0,					/* tp_getattr */
 	0,					/* tp_setattr */
 	0,					/* tp_compare */
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 6bc6085..8cc5058 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -3260,7 +3260,6 @@ inherit_slots(PyTypeObject *type, PyTypeObject *base)
 	basebase = base->tp_base;
 
 	COPYSLOT(tp_dealloc);
-	COPYSLOT(tp_print);
 	if (type->tp_getattr == NULL && type->tp_getattro == NULL) {
 		type->tp_getattr = base->tp_getattr;
 		type->tp_getattro = base->tp_getattro;
@@ -5212,10 +5211,8 @@ static slotdef slotdefs[] = {
 
 	TPSLOT("__str__", tp_str, slot_tp_str, wrap_unaryfunc,
 	       "x.__str__() <==> str(x)"),
-	TPSLOT("__str__", tp_print, NULL, NULL, ""),
 	TPSLOT("__repr__", tp_repr, slot_tp_repr, wrap_unaryfunc,
 	       "x.__repr__() <==> repr(x)"),
-	TPSLOT("__repr__", tp_print, NULL, NULL, ""),
 	TPSLOT("__cmp__", tp_compare, _PyObject_SlotCompare, wrap_cmpfunc,
 	       "x.__cmp__(y) <==> cmp(x,y)"),
 	TPSLOT("__hash__", tp_hash, slot_tp_hash, wrap_hashfunc,