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

#include "Python.h"

#include "frameobject.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. */

static int unlist_types_without_objects;

extern Py_ssize_t tuple_zero_allocs, fast_tuple_allocs;

extern Py_ssize_t quick_int_allocs, quick_neg_int_allocs;

extern Py_ssize_t 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: %" PY_FORMAT_SIZE_T "d, "

"freed: %" PY_FORMAT_SIZE_T "d, "

"max in use: %" PY_FORMAT_SIZE_T "d\n",

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

tp->tp_maxalloc);

fprintf(f, "fast tuple allocs: %" PY_FORMAT_SIZE_T "d, "

"empty: %" PY_FORMAT_SIZE_T "d\n",

fast_tuple_allocs, tuple_zero_allocs);

fprintf(f, "fast int allocs: pos: %" PY_FORMAT_SIZE_T "d, "

"neg: %" PY_FORMAT_SIZE_T "d\n",

quick_int_allocs, quick_neg_int_allocs);

fprintf(f, "null strings: %" PY_FORMAT_SIZE_T "d, "

"1-strings: %" PY_FORMAT_SIZE_T "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 {

#ifdef WITH_THREAD

PyGILState_STATE gil;

#endif

fprintf(stderr, "object : ");

#ifdef WITH_THREAD

gil = PyGILState_Ensure();

#endif

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

#ifdef WITH_THREAD

PyGILState_Release(gil);

#endif

/* 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 = NULL;

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;

}

if (PyInstance_Check(v)) {

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

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

if (!unicodestr) {

unicodestr = PyString_InternFromString("__unicode__");

if (!unicodestr)

return NULL;

}

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__. */

func = _PyObject_LookupSpecial(v, "__unicode__", &unicodestr);

if (func != NULL) {

unicode_method_found = 1;

res = PyObject_CallFunctionObjArgs(func, NULL);

Py_DECREF(func);

}

else if (PyErr_Occurred())

return NULL;

}

/* 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)

return NULL;

if (!PyUnicode_Check(res)) {

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

Py_DECREF(res);

res = str;

}

return res;

}

#endif

/* Helper to warn about deprecated tp_compare return values. Return:

-2 for an exception;

-1 if v < w;

0 if v == w;

1 if v > w.

(This function cannot return 2.)

*/

static int

adjust_tp_compare(int c)

{

if (PyErr_Occurred()) {

if (c != -1 && c != -2) {

PyObject *t, *v, *tb;

PyErr_Fetch(&t, &v, &tb);

if (PyErr_Warn(PyExc_RuntimeWarning,

"tp_compare didn't return -1 or -2 "

"for exception") < 0) {

Py_XDECREF(t);

Py_XDECREF(v);

Py_XDECREF(tb);

}

else

PyErr_Restore(t, v, tb);

}

return -2;

}

else if (c < -1 || c > 1) {

if (PyErr_Warn(PyExc_RuntimeWarning,

"tp_compare didn't return -1, 0 or 1") < 0)

return -2;

else

return c < -1 ? -1 : 1;

}

else {

assert(c >= -1 && c <= 1);

return c;

}

}

/* Macro to get the tp_richcompare field of a type if defined */

#define RICHCOMPARE(t) (PyType_HasFeature((t), Py_TPFLAGS_HAVE_RICHCOMPARE) \

? (t)->tp_richcompare : NULL)

/* Map rich comparison operators to their swapped version, e.g. LT --> GT */

int _Py_SwappedOp[] = {Py_GT, Py_GE, Py_EQ, Py_NE, Py_LT, Py_LE};

/* 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, _Py_SwappedOp[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, _Py_SwappedOp[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;

}

/* 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 3-way comparison, returning an int. Return:

-2 for an exception;

-1 if v < w;

0 if v == w;

1 if v > w;

2 if this particular 3-way comparison is not implemented or undefined.

*/

static int

try_3way_compare(PyObject *v, PyObject *w)

{

int c;

cmpfunc f;

/* Comparisons involving instances are given to instance_compare,

which has the same return conventions as this function. */

f = v->ob_type->tp_compare;

if (PyInstance_Check(v))

return (*f)(v, w);

if (PyInstance_Check(w))

return (*w->ob_type->tp_compare)(v, w);

/* If both have the same (non-NULL) tp_compare, use it. */

if (f != NULL && f == w->ob_type->tp_compare) {

c = (*f)(v, w);

return adjust_tp_compare(c);

}

/* If either tp_compare is _PyObject_SlotCompare, that's safe. */

if (f == _PyObject_SlotCompare ||

w->ob_type->tp_compare == _PyObject_SlotCompare)

return _PyObject_SlotCompare(v, w);

/* If we're here, v and w,

a) are not instances;

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).

*/

c = PyNumber_CoerceEx(&v, &w);

if (c < 0)

return -2;

if (c > 0)

return 2;

f = v->ob_type->tp_compare;

if (f != NULL && f == w->ob_type->tp_compare) {

c = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

return adjust_tp_compare(c);

}

/* No comparison defined */

Py_DECREF(v);

Py_DECREF(w);

return 2;

}

/* Final fallback 3-way comparison, returning an int. Return:

-2 if an error occurred;

-1 if v < w;

0 if v == w;

1 if v > w.

*/

static int

default_3way_compare(PyObject *v, PyObject *w)

{

int c;

const char *vname, *wname;

if (v->ob_type == w->ob_type) {

/* When comparing these pointers, they must be cast to

* integer types (i.e. Py_uintptr_t, our spelling of C9X's

* uintptr_t). ANSI specifies that pointer compares other

* than == and != to non-related structures are undefined.

*/

Py_uintptr_t vv = (Py_uintptr_t)v;

Py_uintptr_t ww = (Py_uintptr_t)w;

return (vv < ww) ? -1 : (vv > ww) ? 1 : 0;

}

/* None is smaller than anything */

if (v == Py_None)

return -1;

if (w == Py_None)

return 1;

/* different type: compare type names; numbers are smaller */

if (PyNumber_Check(v))

vname = "";

else

vname = v->ob_type->tp_name;

if (PyNumber_Check(w))

wname = "";

else

wname = w->ob_type->tp_name;

c = strcmp(vname, wname);

if (c < 0)

return -1;

if (c > 0)

return 1;

/* Same type name, or (more likely) incomparable numeric types */

return ((Py_uintptr_t)(v->ob_type) < (

Py_uintptr_t)(w->ob_type)) ? -1 : 1;

}

/* Do a 3-way comparison, by hook or by crook. Return:

-2 for an exception (but see below);

-1 if v < w;

0 if v == w;

1 if v > w;

BUT: if the object implements a tp_compare function, it returns

whatever this function returns (whether with an exception or not).

*/

static int

do_cmp(PyObject *v, PyObject *w)

{

int c;

cmpfunc f;

if (v->ob_type == w->ob_type

&& (f = v->ob_type->tp_compare) != NULL) {

c = (*f)(v, w);

if (PyInstance_Check(v)) {

/* Instance tp_compare has a different signature.

But if it returns undefined we fall through. */

if (c != 2)

return c;

/* Else fall through to try_rich_to_3way_compare() */

}

else

return adjust_tp_compare(c);

}

/* We only get here if one of the following is true:

a) v and w have different types

b) v and w have the same type, which doesn't have tp_compare

c) v and w are instances, and either __cmp__ is not defined or

__cmp__ returns NotImplemented

*/

c = try_rich_to_3way_compare(v, w);

if (c < 2)

return c;

c = try_3way_compare(v, w);

if (c < 2)

return c;

return default_3way_compare(v, w);

}

/* Compare v to w. Return

-1 if v < w or exception (PyErr_Occurred() true in latter case).

0 if v == w.

1 if v > w.

XXX The docs (C API manual) say the return value is undefined in case

XXX of error.

*/

int

PyObject_Compare(PyObject *v, PyObject *w)

{

int result;

if (v == NULL || w == NULL) {

PyErr_BadInternalCall();

return -1;

}

if (v == w)

return 0;

if (Py_EnterRecursiveCall(" in cmp"))

return -1;

result = do_cmp(v, w);

Py_LeaveRecursiveCall();

return result < 0 ? -1 : result;

}

/* Return (new reference to) Py_True or Py_False. */

static PyObject *

convert_3way_to_object(int op, int c)

{

PyObject *result;

switch (op) {

case Py_LT: c = c < 0; break;

case Py_LE: c = c <= 0; break;

case Py_EQ: c = c == 0; break;

case Py_NE: c = c != 0; break;

case Py_GT: c = c > 0; break;

case Py_GE: c = c >= 0; break;

}

result = c ? Py_True : Py_False;

Py_INCREF(result);

return result;

}

/* We want a rich comparison but don't have one. Try a 3-way cmp instead.

Return

NULL if error

Py_True if v op w

Py_False if not (v op w)

*/

static PyObject *

try_3way_to_rich_compare(PyObject *v, PyObject *w, int op)

{

int c;

c = try_3way_compare(v, w);

if (c >= 2) {

/* Py3K warning if types are not equal and comparison isn't == or != */

if (Py_Py3kWarningFlag &&

v->ob_type != w->ob_type && op != Py_EQ && op != Py_NE &&

PyErr_WarnEx(PyExc_DeprecationWarning,

"comparing unequal types not supported "

"in 3.x", 1) < 0) {

return NULL;

}

c = default_3way_compare(v, w);

}

if (c <= -2)

return NULL;

return convert_3way_to_object(op, c);

}

/* Do rich comparison on v and w. Return

NULL if error

Else a new reference to an object other than Py_NotImplemented, usually(?):

Py_True if v op w

Py_False if not (v op w)

*/

static PyObject *

do_richcmp(PyObject *v, PyObject *w, int op)

{

PyObject *res;

res = try_rich_compare(v, w, op);

if (res != Py_NotImplemented)

return res;

Py_DECREF(res);

return try_3way_to_rich_compare(v, w, op);

}

/* 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 -1 if error; 1 if v op w; 0 if not (v op w). */

int

PyObject_RichCompareBool(PyObject *v, PyObject *w, int op)

{

PyObject *res;

int ok;

/* Quick result when objects are the same.

Guarantees that identity implies equality. */

if (v == w) {

if (op == Py_EQ)

return 1;

else if (op == Py_NE)