#include "Python.h"

#include "pycore_brc.h" // _Py_brc_queue_object()

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_ceval.h" // _Py_EnterRecursiveCallTstate()

#include "pycore_context.h" // _PyContextTokenMissing_Type

#include "pycore_critical_section.h" // Py_BEGIN_CRITICAL_SECTION, Py_END_CRITICAL_SECTION

#include "pycore_descrobject.h" // _PyMethodWrapper_Type

#include "pycore_dict.h" // _PyObject_MakeDictFromInstanceAttributes()

#include "pycore_floatobject.h" // _PyFloat_DebugMallocStats()

#include "pycore_initconfig.h" // _PyStatus_EXCEPTION()

#include "pycore_instruction_sequence.h" // _PyInstructionSequence_Type

#include "pycore_hashtable.h" // _Py_hashtable_new()

#include "pycore_memoryobject.h" // _PyManagedBuffer_Type

#include "pycore_namespace.h" // _PyNamespace_Type

#include "pycore_object.h" // PyAPI_DATA() _Py_SwappedOp definition

#include "pycore_long.h" // _PyLong_GetZero()

#include "pycore_optimizer.h" // _PyUOpExecutor_Type, _PyUOpOptimizer_Type, ...

#include "pycore_pyerrors.h" // _PyErr_Occurred()

#include "pycore_pymem.h" // _PyMem_IsPtrFreed()

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "pycore_symtable.h" // PySTEntry_Type

#include "pycore_typeobject.h" // _PyBufferWrapper_Type

#include "pycore_typevarobject.h" // _PyTypeAlias_Type, _Py_initialize_generic

#include "pycore_unionobject.h" // _PyUnion_Type

#ifdef Py_LIMITED_API

// Prevent recursive call _Py_IncRef() <=> Py_INCREF()

# error "Py_LIMITED_API macro must not be defined"

extern void _PyMem_DumpTraceback(int fd, const void *ptr);

_PyObject_CheckConsistency(PyObject *op, int check_content)

{

#define CHECK(expr) \

do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG(op, Py_STRINGIFY(expr)); } } while (0)

CHECK(!_PyObject_IsFreed(op));

CHECK(Py_REFCNT(op) >= 1);

_PyType_CheckConsistency(Py_TYPE(op));

if (PyUnicode_Check(op)) {

_PyUnicode_CheckConsistency(op, check_content);

}

else if (PyDict_Check(op)) {

_PyDict_CheckConsistency(op, check_content);

}

return 1;

#undef CHECK

}

#ifdef Py_REF_DEBUG

Py_ssize_t _Py_RefTotal;

static inline Py_ssize_t

get_legacy_reftotal(void)

{

return _Py_RefTotal;

}

#ifdef Py_REF_DEBUG

# define REFTOTAL(interp) \

interp->object_state.reftotal

static inline void

reftotal_add(PyThreadState *tstate, Py_ssize_t n)

{

#ifdef Py_GIL_DISABLED

_PyThreadStateImpl *tstate_impl = (_PyThreadStateImpl *)tstate;

// relaxed store to avoid data race with read in get_reftotal()

Py_ssize_t reftotal = tstate_impl->reftotal + n;

_Py_atomic_store_ssize_relaxed(&tstate_impl->reftotal, reftotal);

REFTOTAL(tstate->interp) += n;

}

static inline Py_ssize_t get_global_reftotal(_PyRuntimeState *);

static Py_ssize_t last_final_reftotal = 0;

_Py_FinalizeRefTotal(_PyRuntimeState *runtime)

{

last_final_reftotal = get_global_reftotal(runtime);

runtime->object_state.interpreter_leaks = 0;

}

_PyInterpreterState_FinalizeRefTotal(PyInterpreterState *interp)

{

interp->runtime->object_state.interpreter_leaks += REFTOTAL(interp);

REFTOTAL(interp) = 0;

}

static inline Py_ssize_t

get_reftotal(PyInterpreterState *interp)

{

/* For a single interpreter, we ignore the legacy _Py_RefTotal,

Py_ssize_t total = REFTOTAL(interp);

#ifdef Py_GIL_DISABLED

for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {

/* This may race with other threads modifications to their reftotal */

_PyThreadStateImpl *tstate_impl = (_PyThreadStateImpl *)p;

total += _Py_atomic_load_ssize_relaxed(&tstate_impl->reftotal);

}

return total;

}

static inline Py_ssize_t

get_global_reftotal(_PyRuntimeState *runtime)

{

Py_ssize_t total = 0;

/* Add up the total from each interpreter. */

HEAD_LOCK(&_PyRuntime);

PyInterpreterState *interp = PyInterpreterState_Head();

for (; interp != NULL; interp = PyInterpreterState_Next(interp)) {

total += get_reftotal(interp);

}

HEAD_UNLOCK(&_PyRuntime);

/* Add in the updated value from the legacy _Py_RefTotal. */

total += get_legacy_reftotal();

total += last_final_reftotal;

total += runtime->object_state.interpreter_leaks;

return total;

}

#undef REFTOTAL

_PyDebug_PrintTotalRefs(void) {

_PyRuntimeState *runtime = &_PyRuntime;

fprintf(stderr,

"[%zd refs, %zd blocks]\n",

get_global_reftotal(runtime), _Py_GetGlobalAllocatedBlocks());

/* It may be helpful to also print the "legacy" reftotal separately.

}

#endif /* Py_REF_DEBUG */

#ifdef Py_TRACE_REFS

#define REFCHAIN(interp) interp->object_state.refchain

#define REFCHAIN_VALUE ((void*)(uintptr_t)1)

_PyRefchain_IsTraced(PyInterpreterState *interp, PyObject *obj)

{

return (_Py_hashtable_get(REFCHAIN(interp), obj) == REFCHAIN_VALUE);

}

static void

_PyRefchain_Trace(PyInterpreterState *interp, PyObject *obj)

{

if (_Py_hashtable_set(REFCHAIN(interp), obj, REFCHAIN_VALUE) < 0) {

// Use a fatal error because _Py_NewReference() cannot report

// the error to the caller.

Py_FatalError("_Py_hashtable_set() memory allocation failed");

}

}

static void

_PyRefchain_Remove(PyInterpreterState *interp, PyObject *obj)

{

void *value = _Py_hashtable_steal(REFCHAIN(interp), obj);

#ifndef NDEBUG

assert(value == REFCHAIN_VALUE);

(void)value;

}

_Py_AddToAllObjects(PyObject *op)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

if (!_PyRefchain_IsTraced(interp, op)) {

_PyRefchain_Trace(interp, op);

}

}

#endif /* Py_TRACE_REFS */

#ifdef Py_REF_DEBUG

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

{

_PyObject_AssertFailed(op, NULL, "object has negative ref count",

filename, lineno, __func__);

}

_Py_INCREF_IncRefTotal(void)

{

reftotal_add(_PyThreadState_GET(), 1);

}

_Py_DECREF_DecRefTotal(void)

{

reftotal_add(_PyThreadState_GET(), -1);

}

_Py_IncRefTotal(PyThreadState *tstate)

{

reftotal_add(tstate, 1);

}

_Py_DecRefTotal(PyThreadState *tstate)

{

reftotal_add(tstate, -1);

}

_Py_AddRefTotal(PyThreadState *tstate, Py_ssize_t n)

{

reftotal_add(tstate, n);

}

_Py_GetGlobalRefTotal(void)

{

return get_global_reftotal(&_PyRuntime);

}

_Py_GetLegacyRefTotal(void)

{

return get_legacy_reftotal();

}

_PyInterpreterState_GetRefTotal(PyInterpreterState *interp)

{

HEAD_LOCK(&_PyRuntime);

Py_ssize_t total = get_reftotal(interp);

HEAD_UNLOCK(&_PyRuntime);

return total;

}

#endif /* Py_REF_DEBUG */

Py_IncRef(PyObject *o)

{

Py_XINCREF(o);

}

Py_DecRef(PyObject *o)

{

Py_XDECREF(o);

}

_Py_IncRef(PyObject *o)

{

Py_INCREF(o);

}

_Py_DecRef(PyObject *o)

{

Py_DECREF(o);

}

#ifdef Py_GIL_DISABLED

# ifdef Py_REF_DEBUG

static int

is_dead(PyObject *o)

{

# if SIZEOF_SIZE_T == 8

return (uintptr_t)o->ob_type == 0xDDDDDDDDDDDDDDDD;

return (uintptr_t)o->ob_type == 0xDDDDDDDD;

}

_Py_DecRefSharedDebug(PyObject *o, const char *filename, int lineno)

{

// Should we queue the object for the owning thread to merge?

int should_queue;

Py_ssize_t new_shared;

Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&o->ob_ref_shared);

do {

should_queue = (shared == 0 || shared == _Py_REF_MAYBE_WEAKREF);

if (should_queue) {

// If the object had refcount zero, not queued, and not merged,

// then we enqueue the object to be merged by the owning thread.

// In this case, we don't subtract one from the reference count

// because the queue holds a reference.

new_shared = _Py_REF_QUEUED;

}

else {

// Otherwise, subtract one from the reference count. This might

// be negative!

new_shared = shared - (1 << _Py_REF_SHARED_SHIFT);

}

#ifdef Py_REF_DEBUG

if ((new_shared < 0 && _Py_REF_IS_MERGED(new_shared)) ||

(should_queue && is_dead(o)))

{

_Py_NegativeRefcount(filename, lineno, o);

}

} while (!_Py_atomic_compare_exchange_ssize(&o->ob_ref_shared,

&shared, new_shared));

if (should_queue) {

#ifdef Py_REF_DEBUG

_Py_IncRefTotal(_PyThreadState_GET());

_Py_brc_queue_object(o);

}

else if (new_shared == _Py_REF_MERGED) {

// refcount is zero AND merged

_Py_Dealloc(o);

}

}

_Py_DecRefShared(PyObject *o)

{

_Py_DecRefSharedDebug(o, NULL, 0);

}

_Py_MergeZeroLocalRefcount(PyObject *op)

{

assert(op->ob_ref_local == 0);

Py_ssize_t shared = _Py_atomic_load_ssize_acquire(&op->ob_ref_shared);

if (shared == 0) {

// Fast-path: shared refcount is zero (including flags)

_Py_Dealloc(op);

return;

}

// gh-121794: This must be before the store to `ob_ref_shared` (gh-119999),

// but should outside the fast-path to maintain the invariant that

// a zero `ob_tid` implies a merged refcount.

_Py_atomic_store_uintptr_relaxed(&op->ob_tid, 0);

// Slow-path: atomically set the flags (low two bits) to _Py_REF_MERGED.

Py_ssize_t new_shared;

do {

new_shared = (shared & ~_Py_REF_SHARED_FLAG_MASK) | _Py_REF_MERGED;

} while (!_Py_atomic_compare_exchange_ssize(&op->ob_ref_shared,

&shared, new_shared));

if (new_shared == _Py_REF_MERGED) {

// i.e., the shared refcount is zero (only the flags are set) so we

// deallocate the object.

_Py_Dealloc(op);

}

}

_Py_ExplicitMergeRefcount(PyObject *op, Py_ssize_t extra)

{

assert(!_Py_IsImmortal(op));

#ifdef Py_REF_DEBUG

_Py_AddRefTotal(_PyThreadState_GET(), extra);

// gh-119999: Write to ob_ref_local and ob_tid before merging the refcount.

Py_ssize_t local = (Py_ssize_t)op->ob_ref_local;

_Py_atomic_store_uint32_relaxed(&op->ob_ref_local, 0);

_Py_atomic_store_uintptr_relaxed(&op->ob_tid, 0);

Py_ssize_t refcnt;

Py_ssize_t new_shared;

Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&op->ob_ref_shared);

do {

refcnt = Py_ARITHMETIC_RIGHT_SHIFT(Py_ssize_t, shared, _Py_REF_SHARED_SHIFT);

refcnt += local;

refcnt += extra;

new_shared = _Py_REF_SHARED(refcnt, _Py_REF_MERGED);

} while (!_Py_atomic_compare_exchange_ssize(&op->ob_ref_shared,

&shared, new_shared));

return refcnt;

}

#endif /* Py_GIL_DISABLED */

PyObject *

PyObject_Init(PyObject *op, PyTypeObject *tp)

{

if (op == NULL) {

return PyErr_NoMemory();

}

_PyObject_Init(op, tp);

return op;

}

PyVarObject *

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

{

if (op == NULL) {

return (PyVarObject *) PyErr_NoMemory();

}

_PyObject_InitVar(op, tp, size);

return op;

}

PyObject *

_PyObject_New(PyTypeObject *tp)

{

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

if (op == NULL) {

return PyErr_NoMemory();

}

_PyObject_Init(op, tp);

return op;

}

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();

}

_PyObject_InitVar(op, tp, nitems);

return op;

}

PyObject_CallFinalizer(PyObject *self)

{

PyTypeObject *tp = Py_TYPE(self);

if (tp->tp_finalize == NULL)

return;

/* tp_finalize should only be called once. */

if (_PyType_IS_GC(tp) && _PyGC_FINALIZED(self))

return;

tp->tp_finalize(self);

if (_PyType_IS_GC(tp)) {

_PyGC_SET_FINALIZED(self);

}

}

PyObject_CallFinalizerFromDealloc(PyObject *self)

{

if (Py_REFCNT(self) != 0) {

_PyObject_ASSERT_FAILED_MSG(self,

"PyObject_CallFinalizerFromDealloc called "

"on object with a non-zero refcount");

}

/* Temporarily resurrect the object. */

Py_SET_REFCNT(self, 1);

PyObject_CallFinalizer(self);

_PyObject_ASSERT_WITH_MSG(self,

Py_REFCNT(self) > 0,

"refcount is too small");

/* Undo the temporary resurrection; can't use DECREF here, it would

Py_SET_REFCNT(self, Py_REFCNT(self) - 1);

if (Py_REFCNT(self) == 0) {

return 0; /* this is the normal path out */

}

/* tp_finalize resurrected it! Make it look like the original Py_DECREF

_Py_ResurrectReference(self);

_PyObject_ASSERT(self,

(!_PyType_IS_GC(Py_TYPE(self))

|| _PyObject_GC_IS_TRACKED(self)));

return -1;

}

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

{

int ret = 0;

if (PyErr_CheckSignals())

return -1;

#ifdef USE_STACKCHECK

if (PyOS_CheckStack()) {

PyErr_SetString(PyExc_MemoryError, "stack overflow");

return -1;

}

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

if (op == NULL) {

Py_BEGIN_ALLOW_THREADS

fprintf(fp, "<nil>");

Py_END_ALLOW_THREADS

}

else {

if (Py_REFCNT(op) <= 0) {

Py_BEGIN_ALLOW_THREADS

fprintf(fp, "<refcnt %zd at %p>", Py_REFCNT(op), (void *)op);

Py_END_ALLOW_THREADS

}

else {

PyObject *s;

if (flags & Py_PRINT_RAW)

s = PyObject_Str(op);

else

s = PyObject_Repr(op);

if (s == NULL) {

ret = -1;

}

else {

assert(PyUnicode_Check(s));

const char *t;

Py_ssize_t len;

t = PyUnicode_AsUTF8AndSize(s, &len);

if (t == NULL) {

ret = -1;

}

else {

fwrite(t, 1, len, fp);

}

Py_DECREF(s);

}

}

}

if (ret == 0) {

if (ferror(fp)) {

PyErr_SetFromErrno(PyExc_OSError);

clearerr(fp);

ret = -1;

}

}

return ret;

}

_Py_BreakPoint(void)

{

}

_PyObject_IsFreed(PyObject *op)

{

if (_PyMem_IsPtrFreed(op) || _PyMem_IsPtrFreed(Py_TYPE(op))) {

return 1;

}

return 0;

}

_PyObject_Dump(PyObject* op)

{

if (_PyObject_IsFreed(op)) {

/* It seems like the object memory has been freed:

fprintf(stderr, "<object at %p is freed>\n", op);

fflush(stderr);

return;

}

/* first, write fields which are the least likely to crash */

fprintf(stderr, "object address : %p\n", (void *)op);

fprintf(stderr, "object refcount : %zd\n", Py_REFCNT(op));

fflush(stderr);

PyTypeObject *type = Py_TYPE(op);

fprintf(stderr, "object type : %p\n", type);

fprintf(stderr, "object type name: %s\n",

type==NULL ? "NULL" : type->tp_name);

/* the most dangerous part */

fprintf(stderr, "object repr : ");

fflush(stderr);

PyGILState_STATE gil = PyGILState_Ensure();

PyObject *exc = PyErr_GetRaisedException();

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

fflush(stderr);

PyErr_SetRaisedException(exc);

PyGILState_Release(gil);

fprintf(stderr, "\n");

fflush(stderr);

}

PyObject *

PyObject_Repr(PyObject *v)

{

PyObject *res;

if (PyErr_CheckSignals())

return NULL;

#ifdef USE_STACKCHECK

if (PyOS_CheckStack()) {

PyErr_SetString(PyExc_MemoryError, "stack overflow");

return NULL;

}

if (v == NULL)

return PyUnicode_FromString("<NULL>");

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

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

Py_TYPE(v)->tp_name, v);

PyThreadState *tstate = _PyThreadState_GET();

#ifdef Py_DEBUG

/* PyObject_Repr() must not be called with an exception set,

assert(!_PyErr_Occurred(tstate));

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

if (_Py_EnterRecursiveCallTstate(tstate,

" while getting the repr of an object")) {

return NULL;

}

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

_Py_LeaveRecursiveCallTstate(tstate);

if (res == NULL) {

return NULL;

}

if (!PyUnicode_Check(res)) {

_PyErr_Format(tstate, 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;

if (PyErr_CheckSignals())

return NULL;

#ifdef USE_STACKCHECK

if (PyOS_CheckStack()) {

PyErr_SetString(PyExc_MemoryError, "stack overflow");

return NULL;

}

if (v == NULL)

return PyUnicode_FromString("<NULL>");

if (PyUnicode_CheckExact(v)) {

return Py_NewRef(v);

}

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

return PyObject_Repr(v);

PyThreadState *tstate = _PyThreadState_GET();

#ifdef Py_DEBUG

/* PyObject_Str() must not be called with an exception set,

assert(!_PyErr_Occurred(tstate));

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

if (_Py_EnterRecursiveCallTstate(tstate, " while getting the str of an object")) {

return NULL;

}

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

_Py_LeaveRecursiveCallTstate(tstate);

if (res == NULL) {

return NULL;

}

if (!PyUnicode_Check(res)) {

_PyErr_Format(tstate, PyExc_TypeError,

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

Py_TYPE(res)->tp_name);

Py_DECREF(res);

return NULL;

}

assert(_PyUnicode_CheckConsistency(res, 1));

return res;

}

PyObject *

PyObject_ASCII(PyObject *v)

{

PyObject *repr, *ascii, *res;

repr = PyObject_Repr(v);

if (repr == NULL)

return NULL;

if (PyUnicode_IS_ASCII(repr))

return repr;

/* repr is guaranteed to be a PyUnicode object by PyObject_Repr */

ascii = _PyUnicode_AsASCIIString(repr, "backslashreplace");

Py_DECREF(repr);

if (ascii == NULL)

return NULL;

res = PyUnicode_DecodeASCII(

PyBytes_AS_STRING(ascii),

PyBytes_GET_SIZE(ascii),

NULL);

Py_DECREF(ascii);

return res;

}

PyObject *

PyObject_Bytes(PyObject *v)

{

PyObject *result, *func;

if (v == NULL)

return PyBytes_FromString("<NULL>");

if (PyBytes_CheckExact(v)) {

return Py_NewRef(v);

}

func = _PyObject_LookupSpecial(v, &_Py_ID(__bytes__));

if (func != NULL) {

result = _PyObject_CallNoArgs(func);

Py_DECREF(func);

if (result == NULL)

return NULL;

if (!PyBytes_Check(result)) {

PyErr_Format(PyExc_TypeError,

"__bytes__ returned non-bytes (type %.200s)",

Py_TYPE(result)->tp_name);

Py_DECREF(result);

return NULL;

}

return result;

}

else if (PyErr_Occurred())

return NULL;

return PyBytes_FromObject(v);

}

_PyObject_ClearFreeLists(struct _Py_object_freelists *freelists, int is_finalization)

{

// In the free-threaded build, freelists are per-PyThreadState and cleared in PyThreadState_Clear()

// In the default build, freelists are per-interpreter and cleared in finalize_interp_types()

_PyFloat_ClearFreeList(freelists, is_finalization);

_PyTuple_ClearFreeList(freelists, is_finalization);

_PyList_ClearFreeList(freelists, is_finalization);

_PyDict_ClearFreeList(freelists, is_finalization);

_PyContext_ClearFreeList(freelists, is_finalization);

_PyAsyncGen_ClearFreeLists(freelists, is_finalization);

// Only be cleared if is_finalization is true.

_PyObjectStackChunk_ClearFreeList(freelists, is_finalization);

_PySlice_ClearFreeList(freelists, is_finalization);

}

PyObject *

_PyObject_FunctionStr(PyObject *x)

{

assert(!PyErr_Occurred());

PyObject *qualname;

int ret = PyObject_GetOptionalAttr(x, &_Py_ID(__qualname__), &qualname);

if (qualname == NULL) {

if (ret < 0) {

return NULL;

}

return PyObject_Str(x);

}

PyObject *module;

PyObject *result = NULL;

ret = PyObject_GetOptionalAttr(x, &_Py_ID(__module__), &module);

if (module != NULL && module != Py_None) {

ret = PyObject_RichCompareBool(module, &_Py_ID(builtins), Py_NE);

if (ret < 0) {

// error

goto done;

}

if (ret > 0) {

result = PyUnicode_FromFormat("%S.%S()", module, qualname);

goto done;

}

}

else if (ret < 0) {

goto done;

}

result = PyUnicode_FromFormat("%S()", qualname);

done:

Py_DECREF(qualname);

Py_XDECREF(module);

return result;

}

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

static const char * const opstrings[] = {"<", "<=", "==", "!=", ">", ">="};

static PyObject *

do_richcompare(PyThreadState *tstate, PyObject *v, PyObject *w, int op)

{

richcmpfunc f;

PyObject *res;

int checked_reverse_op = 0;

if (!Py_IS_TYPE(v, Py_TYPE(w)) &&

PyType_IsSubtype(Py_TYPE(w), Py_TYPE(v)) &&

(f = Py_TYPE(w)->tp_richcompare) != NULL) {

checked_reverse_op = 1;

res = (*f)(w, v, _Py_SwappedOp[op]);

if (res != Py_NotImplemented)

return res;

Py_DECREF(res);

}

if ((f = Py_TYPE(v)->tp_richcompare) != NULL) {

res = (*f)(v, w, op);

if (res != Py_NotImplemented)

return res;

Py_DECREF(res);

}

if (!checked_reverse_op && (f = Py_TYPE(w)->tp_richcompare) != NULL) {

res = (*f)(w, v, _Py_SwappedOp[op]);

if (res != Py_NotImplemented)

return res;

Py_DECREF(res);

}

/* If neither object implements it, provide a sensible default

switch (op) {

case Py_EQ:

res = (v == w) ? Py_True : Py_False;

break;

case Py_NE:

res = (v != w) ? Py_True : Py_False;

break;

default:

_PyErr_Format(tstate, PyExc_TypeError,

"'%s' not supported between instances of '%.100s' and '%.100s'",

opstrings[op],

Py_TYPE(v)->tp_name,

Py_TYPE(w)->tp_name);

return NULL;

}

return Py_NewRef(res);

}

PyObject *

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

{

PyThreadState *tstate = _PyThreadState_GET();

assert(Py_LT <= op && op <= Py_GE);

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

if (!_PyErr_Occurred(tstate)) {

PyErr_BadInternalCall();

}

return NULL;

}

if (_Py_EnterRecursiveCallTstate(tstate, " in comparison")) {

return NULL;

}

PyObject *res = do_richcompare(tstate, v, w, op);

_Py_LeaveRecursiveCallTstate(tstate);

return res;

}

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

{

PyObject *res;

int ok;

/* Quick result when objects are the same.

if (v == w) {

if (op == Py_EQ)

return 1;

else if (op == Py_NE)

return 0;

}