Get rid of most of the rest of coerce (slot is still there for now).
diff --git a/Objects/abstract.c b/Objects/abstract.c
index ee137fe..79dfe40 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -339,8 +339,6 @@
/* Binary operators */
-/* New style number protocol support */
-
#define NB_SLOT(x) offsetof(PyNumberMethods, x)
#define NB_BINOP(nb_methods, slot) \
(*(binaryfunc*)(& ((char*)nb_methods)[slot]))
@@ -350,23 +348,11 @@
/*
Calling scheme used for binary operations:
- v w Action
- -------------------------------------------------------------------
- new new w.op(v,w)[*], v.op(v,w), w.op(v,w)
- new old v.op(v,w), coerce(v,w), v.op(v,w)
- old new w.op(v,w), coerce(v,w), v.op(v,w)
- old old coerce(v,w), v.op(v,w)
+ Order operations are tried until either a valid result or error:
+ w.op(v,w)[*], v.op(v,w), w.op(v,w)
[*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of
v->ob_type
-
- Legend:
- -------
- * new == new style number
- * old == old style number
- * Action indicates the order in which operations are tried until either
- a valid result is produced or an error occurs.
-
*/
static PyObject *
@@ -434,29 +420,8 @@
/*
Calling scheme used for ternary operations:
- *** In some cases, w.op is called before v.op; see binary_op1. ***
-
- v w z Action
- -------------------------------------------------------------------
- new new new v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)
- new old new v.op(v,w,z), z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
- old new new w.op(v,w,z), z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
- old old new z.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
- new new old v.op(v,w,z), w.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
- new old old v.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
- old new old w.op(v,w,z), coerce(v,w,z), v.op(v,w,z)
- old old old coerce(v,w,z), v.op(v,w,z)
-
- Legend:
- -------
- * new == new style number
- * old == old style number
- * Action indicates the order in which operations are tried until either
- a valid result is produced or an error occurs.
- * coerce(v,w,z) actually does: coerce(v,w), coerce(v,z), coerce(w,z) and
- only if z != Py_None; if z == Py_None, then it is treated as absent
- variable and only coerce(v,w) is tried.
-
+ Order operations are tried until either a valid result or error:
+ v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)
*/
static PyObject *
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
index aa8fc81..e081256 100644
--- a/Objects/complexobject.c
+++ b/Objects/complexobject.c
@@ -573,65 +573,20 @@
return v->cval.real != 0.0 || v->cval.imag != 0.0;
}
-static int
-complex_coerce(PyObject **pv, PyObject **pw)
-{
- Py_complex cval;
- cval.imag = 0.;
- if (PyInt_Check(*pw)) {
- cval.real = (double)PyInt_AsLong(*pw);
- *pw = PyComplex_FromCComplex(cval);
- Py_INCREF(*pv);
- return 0;
- }
- else if (PyLong_Check(*pw)) {
- cval.real = PyLong_AsDouble(*pw);
- if (cval.real == -1.0 && PyErr_Occurred())
- return -1;
- *pw = PyComplex_FromCComplex(cval);
- Py_INCREF(*pv);
- return 0;
- }
- else if (PyFloat_Check(*pw)) {
- cval.real = PyFloat_AsDouble(*pw);
- *pw = PyComplex_FromCComplex(cval);
- Py_INCREF(*pv);
- return 0;
- }
- else if (PyComplex_Check(*pw)) {
- Py_INCREF(*pv);
- Py_INCREF(*pw);
- return 0;
- }
- return 1; /* Can't do it */
-}
-
static PyObject *
complex_richcompare(PyObject *v, PyObject *w, int op)
{
- int c;
Py_complex i, j;
PyObject *res;
- c = PyNumber_CoerceEx(&v, &w);
- if (c < 0)
- return NULL;
- if (c > 0) {
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
- }
/* Make sure both arguments are complex. */
if (!(PyComplex_Check(v) && PyComplex_Check(w))) {
- Py_DECREF(v);
- Py_DECREF(w);
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
i = ((PyComplexObject *)v)->cval;
j = ((PyComplexObject *)w)->cval;
- Py_DECREF(v);
- Py_DECREF(w);
if (op != Py_EQ && op != Py_NE) {
PyErr_SetString(PyExc_TypeError,
@@ -996,7 +951,7 @@
0, /* nb_and */
0, /* nb_xor */
0, /* nb_or */
- complex_coerce, /* nb_coerce */
+ (coercion)0, /* nb_coerce */
complex_int, /* nb_int */
complex_long, /* nb_long */
complex_float, /* nb_float */
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
index cb0d999..40126b2 100644
--- a/Objects/floatobject.c
+++ b/Objects/floatobject.c
@@ -842,31 +842,6 @@
return v->ob_fval != 0.0;
}
-static int
-float_coerce(PyObject **pv, PyObject **pw)
-{
- if (PyInt_Check(*pw)) {
- long x = PyInt_AsLong(*pw);
- *pw = PyFloat_FromDouble((double)x);
- Py_INCREF(*pv);
- return 0;
- }
- else if (PyLong_Check(*pw)) {
- double x = PyLong_AsDouble(*pw);
- if (x == -1.0 && PyErr_Occurred())
- return -1;
- *pw = PyFloat_FromDouble(x);
- Py_INCREF(*pv);
- return 0;
- }
- else if (PyFloat_Check(*pw)) {
- Py_INCREF(*pv);
- Py_INCREF(*pw);
- return 0;
- }
- return 1; /* Can't do it */
-}
-
static PyObject *
float_long(PyObject *v)
{
@@ -1119,7 +1094,7 @@
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
- float_coerce, /*nb_coerce*/
+ (coercion)0, /*nb_coerce*/
float_int, /*nb_int*/
float_long, /*nb_long*/
float_float, /*nb_float*/
diff --git a/Objects/intobject.c b/Objects/intobject.c
index c378b85..f070404 100644
--- a/Objects/intobject.c
+++ b/Objects/intobject.c
@@ -580,7 +580,7 @@
}
static PyObject *
-int_div(PyIntObject *x, PyIntObject *y)
+int_floor_div(PyIntObject *x, PyIntObject *y)
{
long xi, yi;
long d, m;
@@ -872,17 +872,6 @@
return PyInt_FromLong(a | b);
}
-static int
-int_coerce(PyObject **pv, PyObject **pw)
-{
- if (PyInt_Check(*pw)) {
- Py_INCREF(*pv);
- Py_INCREF(*pw);
- return 0;
- }
- return 1; /* Can't do it */
-}
-
static PyObject *
int_int(PyIntObject *v)
{
@@ -1036,7 +1025,7 @@
(binaryfunc)int_and, /*nb_and*/
(binaryfunc)int_xor, /*nb_xor*/
(binaryfunc)int_or, /*nb_or*/
- int_coerce, /*nb_coerce*/
+ 0, /*nb_coerce*/
(unaryfunc)int_int, /*nb_int*/
(unaryfunc)int_long, /*nb_long*/
(unaryfunc)int_float, /*nb_float*/
@@ -1052,7 +1041,7 @@
0, /*nb_inplace_and*/
0, /*nb_inplace_xor*/
0, /*nb_inplace_or*/
- (binaryfunc)int_div, /* nb_floor_divide */
+ (binaryfunc)int_floor_div, /* nb_floor_divide */
int_true_divide, /* nb_true_divide */
0, /* nb_inplace_floor_divide */
0, /* nb_inplace_true_divide */
diff --git a/Objects/object.c b/Objects/object.c
index 516098d..44b3f7d 100644
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -681,9 +681,7 @@
b) have different types or a type without tp_compare; and
c) don't have a user-defined tp_compare.
tp_compare implementations in C assume that both arguments
- have their type, so we give up if the coercion fails or if
- it yields types which are still incompatible (which can
- happen with a user-defined nb_coerce).
+ have their type, so we give up if the coercion fails.
*/
c = PyNumber_CoerceEx(&v, &w);
if (c < 0)
@@ -1513,22 +1511,6 @@
return 1;
}
-/* Coerce two numeric types to the "larger" one.
- Increment the reference count on each argument.
- Return -1 and raise an exception if no coercion is possible
- (and then no reference count is incremented).
-*/
-int
-PyNumber_Coerce(PyObject **pv, PyObject **pw)
-{
- int err = PyNumber_CoerceEx(pv, pw);
- if (err <= 0)
- return err;
- PyErr_SetString(PyExc_TypeError, "number coercion failed");
- return -1;
-}
-
-
/* Test whether an object can be called */
int
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 02d45bd..e9ffa87 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -3327,34 +3327,6 @@
}
static PyObject *
-wrap_coercefunc(PyObject *self, PyObject *args, void *wrapped)
-{
- coercion func = (coercion)wrapped;
- PyObject *other, *res;
- int ok;
-
- if (!check_num_args(args, 1))
- return NULL;
- other = PyTuple_GET_ITEM(args, 0);
- ok = func(&self, &other);
- if (ok < 0)
- return NULL;
- if (ok > 0) {
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
- }
- res = PyTuple_New(2);
- if (res == NULL) {
- Py_DECREF(self);
- Py_DECREF(other);
- return NULL;
- }
- PyTuple_SET_ITEM(res, 0, self);
- PyTuple_SET_ITEM(res, 1, other);
- return res;
-}
-
-static PyObject *
wrap_ternaryfunc(PyObject *self, PyObject *args, void *wrapped)
{
ternaryfunc func = (ternaryfunc)wrapped;
@@ -4247,64 +4219,6 @@
SLOT1BIN(slot_nb_xor, nb_xor, "__xor__", "__rxor__")
SLOT1BIN(slot_nb_or, nb_or, "__or__", "__ror__")
-static int
-slot_nb_coerce(PyObject **a, PyObject **b)
-{
- static PyObject *coerce_str;
- PyObject *self = *a, *other = *b;
-
- if (self->ob_type->tp_as_number != NULL &&
- self->ob_type->tp_as_number->nb_coerce == slot_nb_coerce) {
- PyObject *r;
- r = call_maybe(
- self, "__coerce__", &coerce_str, "(O)", other);
- if (r == NULL)
- return -1;
- if (r == Py_NotImplemented) {
- Py_DECREF(r);
- }
- else {
- if (!PyTuple_Check(r) || PyTuple_GET_SIZE(r) != 2) {
- PyErr_SetString(PyExc_TypeError,
- "__coerce__ didn't return a 2-tuple");
- Py_DECREF(r);
- return -1;
- }
- *a = PyTuple_GET_ITEM(r, 0);
- Py_INCREF(*a);
- *b = PyTuple_GET_ITEM(r, 1);
- Py_INCREF(*b);
- Py_DECREF(r);
- return 0;
- }
- }
- if (other->ob_type->tp_as_number != NULL &&
- other->ob_type->tp_as_number->nb_coerce == slot_nb_coerce) {
- PyObject *r;
- r = call_maybe(
- other, "__coerce__", &coerce_str, "(O)", self);
- if (r == NULL)
- return -1;
- if (r == Py_NotImplemented) {
- Py_DECREF(r);
- return 1;
- }
- if (!PyTuple_Check(r) || PyTuple_GET_SIZE(r) != 2) {
- PyErr_SetString(PyExc_TypeError,
- "__coerce__ didn't return a 2-tuple");
- Py_DECREF(r);
- return -1;
- }
- *a = PyTuple_GET_ITEM(r, 1);
- Py_INCREF(*a);
- *b = PyTuple_GET_ITEM(r, 0);
- Py_INCREF(*b);
- Py_DECREF(r);
- return 0;
- }
- return 1;
-}
-
SLOT0(slot_nb_int, "__int__")
SLOT0(slot_nb_long, "__long__")
SLOT0(slot_nb_float, "__float__")
@@ -4958,8 +4872,6 @@
RBINSLOT("__rxor__", nb_xor, slot_nb_xor, "^"),
BINSLOT("__or__", nb_or, slot_nb_or, "|"),
RBINSLOT("__ror__", nb_or, slot_nb_or, "|"),
- NBSLOT("__coerce__", nb_coerce, slot_nb_coerce, wrap_coercefunc,
- "x.__coerce__(y) <==> coerce(x, y)"),
UNSLOT("__int__", nb_int, slot_nb_int, wrap_unaryfunc,
"int(x)"),
UNSLOT("__long__", nb_long, slot_nb_long, wrap_unaryfunc,