/* Try rich comparisons to determine a 3-way comparison. Return: -2 for an exception; -1 if v < w; 0 if v == w; 1 if v > w; 2 if this particular rich comparison is not implemented or undefined. */ static int try_rich_to_3way_compare(PyObject *v, PyObject *w) { static struct { int op; int outcome; } tries[3] = { /* Try this operator, and if it is true, use this outcome: */ {Py_EQ, 0}, {Py_LT, -1}, {Py_GT, 1}, }; int i; if (RICHCOMPARE(v->ob_type) == NULL && RICHCOMPARE(w->ob_type) == NULL) return 2; /* Shortcut */ for (i = 0; i < 3; i++) { switch (try_rich_compare_bool(v, w, tries[i].op)) { case -1: return -2; case 1: return tries[i].outcome; } } return 2; }
/* Try a genuine rich comparison, returning an object. Return: NULL for exception; NotImplemented if this particular rich comparison is not implemented or undefined; some object not equal to NotImplemented if it is implemented (this latter object may not be a Boolean). */ static PyObject * try_rich_compare(PyObject *v, PyObject *w, int op) { richcmpfunc f; PyObject *res; if (v->ob_type != w->ob_type && PyType_IsSubtype(w->ob_type, v->ob_type) && (f = RICHCOMPARE(w->ob_type)) != NULL) { res = (*f)(w, v, swapped_op[op]); if (res != Py_NotImplemented) return res; Py_DECREF(res); } if ((f = RICHCOMPARE(v->ob_type)) != NULL) { res = (*f)(v, w, op); if (res != Py_NotImplemented) return res; Py_DECREF(res); } if ((f = RICHCOMPARE(w->ob_type)) != NULL) { return (*f)(w, v, swapped_op[op]); } res = Py_NotImplemented; Py_INCREF(res); return res; }
/* Try a genuine rich comparison, returning an int. Return: -1 for exception (including the case where try_rich_compare() returns an object that's not a Boolean); 0 if the outcome is false; 1 if the outcome is true; 2 if this particular rich comparison is not implemented or undefined. */ static int try_rich_compare_bool(PyObject *v, PyObject *w, int op) { PyObject *res; int ok; if (RICHCOMPARE(v->ob_type) == NULL && RICHCOMPARE(w->ob_type) == NULL) return 2; /* Shortcut, avoid INCREF+DECREF */ res = try_rich_compare(v, w, op); if (res == NULL) return -1; if (res == Py_NotImplemented) { Py_DECREF(res); return 2; } ok = PyObject_IsTrue(res); Py_DECREF(res); return ok; }
long PyObject_Hash(PyObject *v) { PyTypeObject *tp = v->ob_type; if (tp->tp_hash != NULL) return (*tp->tp_hash)(v); if (tp->tp_compare == NULL && RICHCOMPARE(tp) == NULL) { return _Py_HashPointer(v); /* Use address as hash value */ } /* If there's a cmp but no hash defined, the object can't be hashed */ PyErr_SetString(PyExc_TypeError, "unhashable type"); return -1; }
/* Return: NULL for exception; some object not equal to NotImplemented if it is implemented (this latter object may not be a Boolean). */ PyObject * PyObject_RichCompare(PyObject *v, PyObject *w, int op) { PyObject *res; assert(Py_LT <= op && op <= Py_GE); if (Py_EnterRecursiveCall(" in cmp")) return NULL; /* If the types are equal, and not old-style instances, try to get out cheap (don't bother with coercions etc.). */ if (v->ob_type == w->ob_type && !PyInstance_Check(v)) { cmpfunc fcmp; richcmpfunc frich = RICHCOMPARE(v->ob_type); /* If the type has richcmp, try it first. try_rich_compare tries it two-sided, which is not needed since we've a single type only. */ if (frich != NULL) { res = (*frich)(v, w, op); if (res != Py_NotImplemented) goto Done; Py_DECREF(res); } /* No richcmp, or this particular richmp not implemented. Try 3-way cmp. */ fcmp = v->ob_type->tp_compare; if (fcmp != NULL) { int c = (*fcmp)(v, w); c = adjust_tp_compare(c); if (c == -2) { res = NULL; goto Done; } res = convert_3way_to_object(op, c); goto Done; } } /* Fast path not taken, or couldn't deliver a useful result. */ res = do_richcmp(v, w, op); Done: Py_LeaveRecursiveCall(); return res; }
/* Return: NULL for exception; some object not equal to NotImplemented if it is implemented (this latter object may not be a Boolean). */ PyObject * PyObject_RichCompare(PyObject *v, PyObject *w, int op) { PyObject *res; assert(Py_LT <= op && op <= Py_GE); compare_nesting++; if (compare_nesting > NESTING_LIMIT && (v->ob_type->tp_as_mapping || (v->ob_type->tp_as_sequence && !PyString_Check(v) && !PyTuple_Check(v)))) { /* try to detect circular data structures */ PyObject *token = check_recursion(v, w, op); if (token == NULL) { res = NULL; goto Done; } else if (token == Py_None) { /* already comparing these objects with this operator. assume they're equal until shown otherwise */ if (op == Py_EQ) res = Py_True; else if (op == Py_NE) res = Py_False; else { PyErr_SetString(PyExc_ValueError, "can't order recursive values"); res = NULL; } Py_XINCREF(res); } else { res = do_richcmp(v, w, op); delete_token(token); } goto Done; } /* No nesting extremism. If the types are equal, and not old-style instances, try to get out cheap (don't bother with coercions etc.). */ if (v->ob_type == w->ob_type && !PyInstance_Check(v)) { cmpfunc fcmp; richcmpfunc frich = RICHCOMPARE(v->ob_type); /* If the type has richcmp, try it first. try_rich_compare tries it two-sided, which is not needed since we've a single type only. */ if (frich != NULL) { res = (*frich)(v, w, op); if (res != Py_NotImplemented) goto Done; Py_DECREF(res); } /* No richcmp, or this particular richmp not implemented. Try 3-way cmp. */ fcmp = v->ob_type->tp_compare; if (fcmp != NULL) { int c = (*fcmp)(v, w); if (c < 0 && PyErr_Occurred()) { res = NULL; goto Done; } res = convert_3way_to_object(op, c); goto Done; } } /* Fast path not taken, or couldn't deliver a useful result. */ res = do_richcmp(v, w, op); Done: compare_nesting--; return res; }