From dffe4c07095e0c693e094d3c140e85a68bd8128e Mon Sep 17 00:00:00 2001 From: Andy Lester Date: Wed, 4 Mar 2020 07:15:20 -0600 Subject: bpo-39573: Finish converting to new Py_IS_TYPE() macro (GH-18601) --- Include/py_curses.h | 3 +-- Modules/_asynciomodule.c | 2 +- Modules/_collectionsmodule.c | 2 +- Modules/_elementtree.c | 2 +- Modules/_io/bufferedio.c | 12 ++++++------ Modules/_io/stringio.c | 2 +- Modules/_io/textio.c | 16 ++++++++-------- Modules/_pickle.c | 4 ++-- Modules/_threadmodule.c | 4 ++-- Modules/cjkcodecs/multibytecodec.h | 2 +- Modules/itertoolsmodule.c | 2 +- Objects/abstract.c | 2 +- Objects/descrobject.c | 4 ++-- Objects/exceptions.c | 4 ++-- Objects/genobject.c | 6 +++--- Objects/listobject.c | 22 +++++++++++----------- Objects/namespaceobject.c | 2 +- Objects/tupleobject.c | 2 +- Objects/typeobject.c | 8 ++++---- Objects/unicodeobject.c | 4 ++-- Python/ceval.c | 4 ++-- Python/errors.c | 2 +- Python/importdl.c | 2 +- 23 files changed, 56 insertions(+), 57 deletions(-) diff --git a/Include/py_curses.h b/Include/py_curses.h index 2702b37..b70252d 100644 --- a/Include/py_curses.h +++ b/Include/py_curses.h @@ -64,7 +64,7 @@ typedef struct { char *encoding; } PyCursesWindowObject; -#define PyCursesWindow_Check(v) (Py_TYPE(v) == &PyCursesWindow_Type) +#define PyCursesWindow_Check(v) Py_IS_TYPE(v, &PyCursesWindow_Type) #define PyCurses_CAPSULE_NAME "_curses._C_API" @@ -97,4 +97,3 @@ static const char catchall_NULL[] = "curses function returned NULL"; #endif /* !defined(Py_CURSES_H) */ - diff --git a/Modules/_asynciomodule.c b/Modules/_asynciomodule.c index 5674330..d394002 100644 --- a/Modules/_asynciomodule.c +++ b/Modules/_asynciomodule.c @@ -572,7 +572,7 @@ future_set_exception(FutureObj *fut, PyObject *exc) PyErr_SetString(PyExc_TypeError, "invalid exception object"); return NULL; } - if ((PyObject*)Py_TYPE(exc_val) == PyExc_StopIteration) { + if (Py_IS_TYPE(exc_val, (PyTypeObject *)PyExc_StopIteration)) { Py_DECREF(exc_val); PyErr_SetString(PyExc_TypeError, "StopIteration interacts badly with generators " diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c index 057d404..4d5d874 100644 --- a/Modules/_collectionsmodule.c +++ b/Modules/_collectionsmodule.c @@ -489,7 +489,7 @@ deque_copy(PyObject *deque, PyObject *Py_UNUSED(ignored)) { PyObject *result; dequeobject *old_deque = (dequeobject *)deque; - if (Py_TYPE(deque) == &deque_type) { + if (Py_IS_TYPE(deque, &deque_type)) { dequeobject *new_deque; PyObject *rv; diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c index c0f771f..cc06824 100644 --- a/Modules/_elementtree.c +++ b/Modules/_elementtree.c @@ -2366,7 +2366,7 @@ typedef struct { char insert_pis; } TreeBuilderObject; -#define TreeBuilder_CheckExact(op) (Py_TYPE(op) == &TreeBuilder_Type) +#define TreeBuilder_CheckExact(op) Py_IS_TYPE((op), &TreeBuilder_Type) /* -------------------------------------------------------------------- */ /* constructor and destructor */ diff --git a/Modules/_io/bufferedio.c b/Modules/_io/bufferedio.c index a09082c..f2d0467 100644 --- a/Modules/_io/bufferedio.c +++ b/Modules/_io/bufferedio.c @@ -1449,8 +1449,8 @@ _io_BufferedReader___init___impl(buffered *self, PyObject *raw, return -1; _bufferedreader_reset_buf(self); - self->fast_closed_checks = (Py_TYPE(self) == &PyBufferedReader_Type && - Py_TYPE(raw) == &PyFileIO_Type); + self->fast_closed_checks = (Py_IS_TYPE(self, &PyBufferedReader_Type) && + Py_IS_TYPE(raw, &PyFileIO_Type)); self->ok = 1; return 0; @@ -1795,8 +1795,8 @@ _io_BufferedWriter___init___impl(buffered *self, PyObject *raw, _bufferedwriter_reset_buf(self); self->pos = 0; - self->fast_closed_checks = (Py_TYPE(self) == &PyBufferedWriter_Type && - Py_TYPE(raw) == &PyFileIO_Type); + self->fast_closed_checks = (Py_IS_TYPE(self, &PyBufferedWriter_Type) && + Py_IS_TYPE(raw, &PyFileIO_Type)); self->ok = 1; return 0; @@ -2309,8 +2309,8 @@ _io_BufferedRandom___init___impl(buffered *self, PyObject *raw, _bufferedwriter_reset_buf(self); self->pos = 0; - self->fast_closed_checks = (Py_TYPE(self) == &PyBufferedRandom_Type && - Py_TYPE(raw) == &PyFileIO_Type); + self->fast_closed_checks = (Py_IS_TYPE(self, &PyBufferedRandom_Type) && + Py_IS_TYPE(raw, &PyFileIO_Type)); self->ok = 1; return 0; diff --git a/Modules/_io/stringio.c b/Modules/_io/stringio.c index 28d54e0..9feb76e 100644 --- a/Modules/_io/stringio.c +++ b/Modules/_io/stringio.c @@ -402,7 +402,7 @@ stringio_iternext(stringio *self) CHECK_CLOSED(self); ENSURE_REALIZED(self); - if (Py_TYPE(self) == &PyStringIO_Type) { + if (Py_IS_TYPE(self, &PyStringIO_Type)) { /* Skip method call overhead for speed */ line = _stringio_readline(self, -1); } diff --git a/Modules/_io/textio.c b/Modules/_io/textio.c index 3a9ce93..dedbefe 100644 --- a/Modules/_io/textio.c +++ b/Modules/_io/textio.c @@ -897,7 +897,7 @@ _textiowrapper_decode(PyObject *decoder, PyObject *bytes, int eof) { PyObject *chars; - if (Py_TYPE(decoder) == &PyIncrementalNewlineDecoder_Type) + if (Py_IS_TYPE(decoder, &PyIncrementalNewlineDecoder_Type)) chars = _PyIncrementalNewlineDecoder_decode(decoder, bytes, eof); else chars = PyObject_CallMethodObjArgs(decoder, _PyIO_str_decode, bytes, @@ -1226,15 +1226,15 @@ _io_TextIOWrapper___init___impl(textio *self, PyObject *buffer, /* Finished sorting out the codec details */ Py_CLEAR(codec_info); - if (Py_TYPE(buffer) == &PyBufferedReader_Type || - Py_TYPE(buffer) == &PyBufferedWriter_Type || - Py_TYPE(buffer) == &PyBufferedRandom_Type) + if (Py_IS_TYPE(buffer, &PyBufferedReader_Type) || + Py_IS_TYPE(buffer, &PyBufferedWriter_Type) || + Py_IS_TYPE(buffer, &PyBufferedRandom_Type)) { if (_PyObject_LookupAttrId(buffer, &PyId_raw, &raw) < 0) goto error; /* Cache the raw FileIO object to speed up 'closed' checks */ if (raw != NULL) { - if (Py_TYPE(raw) == &PyFileIO_Type) + if (Py_IS_TYPE(raw, &PyFileIO_Type)) self->raw = raw; else Py_DECREF(raw); @@ -1466,7 +1466,7 @@ textiowrapper_closed_get(textio *self, void *context); do { \ int r; \ PyObject *_res; \ - if (Py_TYPE(self) == &PyTextIOWrapper_Type) { \ + if (Py_IS_TYPE(self, &PyTextIOWrapper_Type)) { \ if (self->raw != NULL) \ r = _PyFileIO_closed(self->raw); \ else { \ @@ -1937,7 +1937,7 @@ _io_TextIOWrapper_read_impl(textio *self, Py_ssize_t n) if (bytes == NULL) goto fail; - if (Py_TYPE(self->decoder) == &PyIncrementalNewlineDecoder_Type) + if (Py_IS_TYPE(self->decoder, &PyIncrementalNewlineDecoder_Type)) decoded = _PyIncrementalNewlineDecoder_decode(self->decoder, bytes, 1); else @@ -3079,7 +3079,7 @@ textiowrapper_iternext(textio *self) CHECK_ATTACHED(self); self->telling = 0; - if (Py_TYPE(self) == &PyTextIOWrapper_Type) { + if (Py_IS_TYPE(self, &PyTextIOWrapper_Type)) { /* Skip method call overhead for speed */ line = _textiowrapper_readline(self, -1); } diff --git a/Modules/_pickle.c b/Modules/_pickle.c index bcbd3c0..6b903da 100644 --- a/Modules/_pickle.c +++ b/Modules/_pickle.c @@ -4974,7 +4974,7 @@ Pickler_set_memo(PicklerObject *self, PyObject *obj, void *Py_UNUSED(ignored)) return -1; } - if (Py_TYPE(obj) == &PicklerMemoProxyType) { + if (Py_IS_TYPE(obj, &PicklerMemoProxyType)) { PicklerObject *pickler = ((PicklerMemoProxyObject *)obj)->pickler; @@ -7519,7 +7519,7 @@ Unpickler_set_memo(UnpicklerObject *self, PyObject *obj, void *Py_UNUSED(ignored return -1; } - if (Py_TYPE(obj) == &UnpicklerMemoProxyType) { + if (Py_IS_TYPE(obj, &UnpicklerMemoProxyType)) { UnpicklerObject *unpickler = ((UnpicklerMemoProxyObject *)obj)->unpickler; diff --git a/Modules/_threadmodule.c b/Modules/_threadmodule.c index 4a651ce..da5fe79 100644 --- a/Modules/_threadmodule.c +++ b/Modules/_threadmodule.c @@ -844,7 +844,7 @@ _ldict(localobject *self) } } else { - assert(Py_TYPE(dummy) == &localdummytype); + assert(Py_IS_TYPE(dummy, &localdummytype)); ldict = ((localdummyobject *) dummy)->localdict; } @@ -1209,7 +1209,7 @@ release_sentinel(void *wr_raw) PyObject *obj = PyWeakref_GET_OBJECT(wr); lockobject *lock; if (obj != Py_None) { - assert(Py_TYPE(obj) == &Locktype); + assert(Py_IS_TYPE(obj, &Locktype)); lock = (lockobject *) obj; if (lock->locked) { PyThread_release_lock(lock->lock_lock); diff --git a/Modules/cjkcodecs/multibytecodec.h b/Modules/cjkcodecs/multibytecodec.h index 94670ec..4d2b355 100644 --- a/Modules/cjkcodecs/multibytecodec.h +++ b/Modules/cjkcodecs/multibytecodec.h @@ -65,7 +65,7 @@ typedef struct { MultibyteCodec *codec; } MultibyteCodecObject; -#define MultibyteCodec_Check(op) (Py_TYPE(op) == &MultibyteCodec_Type) +#define MultibyteCodec_Check(op) Py_IS_TYPE((op), &MultibyteCodec_Type) #define _MultibyteStatefulCodec_HEAD \ PyObject_HEAD \ diff --git a/Modules/itertoolsmodule.c b/Modules/itertoolsmodule.c index c00c274..d545028 100644 --- a/Modules/itertoolsmodule.c +++ b/Modules/itertoolsmodule.c @@ -527,7 +527,7 @@ teedataobject_traverse(teedataobject *tdo, visitproc visit, void * arg) static void teedataobject_safe_decref(PyObject *obj) { - while (obj && Py_TYPE(obj) == &teedataobject_type && + while (obj && Py_IS_TYPE(obj, &teedataobject_type) && Py_REFCNT(obj) == 1) { PyObject *nextlink = ((teedataobject *)obj)->nextlink; ((teedataobject *)obj)->nextlink = NULL; diff --git a/Objects/abstract.c b/Objects/abstract.c index de5652f..454e0da 100644 --- a/Objects/abstract.c +++ b/Objects/abstract.c @@ -2472,7 +2472,7 @@ object_recursive_isinstance(PyThreadState *tstate, PyObject *inst, PyObject *cls _Py_IDENTIFIER(__instancecheck__); /* Quick test for an exact match */ - if (Py_TYPE(inst) == (PyTypeObject *)cls) { + if (Py_IS_TYPE(inst, (PyTypeObject *)cls)) { return 1; } diff --git a/Objects/descrobject.c b/Objects/descrobject.c index aaaa447..c96945b 100644 --- a/Objects/descrobject.c +++ b/Objects/descrobject.c @@ -1178,7 +1178,7 @@ typedef struct { PyObject *self; } wrapperobject; -#define Wrapper_Check(v) (Py_TYPE(v) == &_PyMethodWrapper_Type) +#define Wrapper_Check(v) Py_IS_TYPE(v, &_PyMethodWrapper_Type) static void wrapper_dealloc(wrapperobject *wp) @@ -1628,7 +1628,7 @@ property_init_impl(propertyobject *self, PyObject *fget, PyObject *fset, if (rc <= 0) { return rc; } - if (Py_TYPE(self) == &PyProperty_Type) { + if (Py_IS_TYPE(self, &PyProperty_Type)) { Py_XSETREF(self->prop_doc, get_doc); } else { diff --git a/Objects/exceptions.c b/Objects/exceptions.c index 631f537..2baec5e 100644 --- a/Objects/exceptions.c +++ b/Objects/exceptions.c @@ -875,7 +875,7 @@ oserror_init(PyOSErrorObject *self, PyObject **p_args, /* self->filename will remain Py_None otherwise */ if (filename && filename != Py_None) { - if (Py_TYPE(self) == (PyTypeObject *) PyExc_BlockingIOError && + if (Py_IS_TYPE(self, (PyTypeObject *) PyExc_BlockingIOError) && PyNumber_Check(filename)) { /* BlockingIOError's 3rd argument can be the number of * characters written. @@ -1379,7 +1379,7 @@ SyntaxError_init(PySyntaxErrorObject *self, PyObject *args, PyObject *kwds) * Only applies to SyntaxError instances, not to subclasses such * as TabError or IndentationError (see issue #31161) */ - if ((PyObject*)Py_TYPE(self) == PyExc_SyntaxError && + if (Py_IS_TYPE(self, (PyTypeObject *)PyExc_SyntaxError) && self->text && PyUnicode_Check(self->text) && _report_missing_parentheses(self) < 0) { return -1; diff --git a/Objects/genobject.c b/Objects/genobject.c index ef892bb..6bb08ae 100644 --- a/Objects/genobject.c +++ b/Objects/genobject.c @@ -1216,10 +1216,10 @@ static PyAsyncGenASend *ag_asend_freelist[_PyAsyncGen_MAXFREELIST]; static int ag_asend_freelist_free = 0; #define _PyAsyncGenWrappedValue_CheckExact(o) \ - (Py_TYPE(o) == &_PyAsyncGenWrappedValue_Type) + Py_IS_TYPE(o, &_PyAsyncGenWrappedValue_Type) #define PyAsyncGenASend_CheckExact(o) \ - (Py_TYPE(o) == &_PyAsyncGenASend_Type) + Py_IS_TYPE(o, &_PyAsyncGenASend_Type) static int @@ -1442,7 +1442,7 @@ PyAsyncGen_ClearFreeLists(void) while (ag_asend_freelist_free) { PyAsyncGenASend *o; o = ag_asend_freelist[--ag_asend_freelist_free]; - assert(Py_TYPE(o) == &_PyAsyncGenASend_Type); + assert(Py_IS_TYPE(o, &_PyAsyncGenASend_Type)); PyObject_GC_Del(o); } diff --git a/Objects/listobject.c b/Objects/listobject.c index 3ac03b7..46bc777 100644 --- a/Objects/listobject.c +++ b/Objects/listobject.c @@ -2052,8 +2052,8 @@ unsafe_latin_compare(PyObject *v, PyObject *w, MergeState *ms) int res; /* Modified from Objects/unicodeobject.c:unicode_compare, assuming: */ - assert(Py_TYPE(v) == Py_TYPE(w)); - assert(Py_TYPE(v) == &PyUnicode_Type); + assert(Py_IS_TYPE(v, &PyUnicode_Type)); + assert(Py_IS_TYPE(w, &PyUnicode_Type)); assert(PyUnicode_KIND(v) == PyUnicode_KIND(w)); assert(PyUnicode_KIND(v) == PyUnicode_1BYTE_KIND); @@ -2075,8 +2075,8 @@ unsafe_long_compare(PyObject *v, PyObject *w, MergeState *ms) PyLongObject *vl, *wl; sdigit v0, w0; int res; /* Modified from Objects/longobject.c:long_compare, assuming: */ - assert(Py_TYPE(v) == Py_TYPE(w)); - assert(Py_TYPE(v) == &PyLong_Type); + assert(Py_IS_TYPE(v, &PyLong_Type)); + assert(Py_IS_TYPE(w, &PyLong_Type)); assert(Py_ABS(Py_SIZE(v)) <= 1); assert(Py_ABS(Py_SIZE(w)) <= 1); @@ -2103,8 +2103,8 @@ unsafe_float_compare(PyObject *v, PyObject *w, MergeState *ms) int res; /* Modified from Objects/floatobject.c:float_richcompare, assuming: */ - assert(Py_TYPE(v) == Py_TYPE(w)); - assert(Py_TYPE(v) == &PyFloat_Type); + assert(Py_IS_TYPE(v, &PyFloat_Type)); + assert(Py_IS_TYPE(w, &PyFloat_Type)); res = PyFloat_AS_DOUBLE(v) < PyFloat_AS_DOUBLE(w); assert(res == PyObject_RichCompareBool(v, w, Py_LT)); @@ -2125,8 +2125,8 @@ unsafe_tuple_compare(PyObject *v, PyObject *w, MergeState *ms) int k; /* Modified from Objects/tupleobject.c:tuplerichcompare, assuming: */ - assert(Py_TYPE(v) == Py_TYPE(w)); - assert(Py_TYPE(v) == &PyTuple_Type); + assert(Py_IS_TYPE(v, &PyTuple_Type)); + assert(Py_IS_TYPE(w, &PyTuple_Type)); assert(Py_SIZE(v) > 0); assert(Py_SIZE(w) > 0); @@ -2247,7 +2247,7 @@ list_sort_impl(PyListObject *self, PyObject *keyfunc, int reverse) * set ms appropriately. */ if (saved_ob_size > 1) { /* Assume the first element is representative of the whole list. */ - int keys_are_in_tuples = (Py_TYPE(lo.keys[0]) == &PyTuple_Type && + int keys_are_in_tuples = (Py_IS_TYPE(lo.keys[0], &PyTuple_Type) && Py_SIZE(lo.keys[0]) > 0); PyTypeObject* key_type = (keys_are_in_tuples ? @@ -2262,7 +2262,7 @@ list_sort_impl(PyListObject *self, PyObject *keyfunc, int reverse) for (i=0; i < saved_ob_size; i++) { if (keys_are_in_tuples && - !(Py_TYPE(lo.keys[i]) == &PyTuple_Type && Py_SIZE(lo.keys[i]) != 0)) { + !(Py_IS_TYPE(lo.keys[i], &PyTuple_Type) && Py_SIZE(lo.keys[i]) != 0)) { keys_are_in_tuples = 0; keys_are_all_same_type = 0; break; @@ -2275,7 +2275,7 @@ list_sort_impl(PyListObject *self, PyObject *keyfunc, int reverse) PyTuple_GET_ITEM(lo.keys[i], 0) : lo.keys[i]); - if (Py_TYPE(key) != key_type) { + if (!Py_IS_TYPE(key, key_type)) { keys_are_all_same_type = 0; /* If keys are in tuple we must loop over the whole list to make sure all items are tuples */ diff --git a/Objects/namespaceobject.c b/Objects/namespaceobject.c index 5c7163f..a28b9e5 100644 --- a/Objects/namespaceobject.c +++ b/Objects/namespaceobject.c @@ -72,7 +72,7 @@ namespace_repr(PyObject *ns) PyObject *separator, *pairsrepr, *repr = NULL; const char * name; - name = (Py_TYPE(ns) == &_PyNamespace_Type) ? "namespace" + name = Py_IS_TYPE(ns, &_PyNamespace_Type) ? "namespace" : Py_TYPE(ns)->tp_name; i = Py_ReprEnter(ns); diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c index d114bd6..92374cc 100644 --- a/Objects/tupleobject.c +++ b/Objects/tupleobject.c @@ -237,7 +237,7 @@ tupledealloc(PyTupleObject *op) #if PyTuple_MAXSAVESIZE > 0 if (len < PyTuple_MAXSAVESIZE && numfree[len] < PyTuple_MAXFREELIST && - Py_TYPE(op) == &PyTuple_Type) + Py_IS_TYPE(op, &PyTuple_Type)) { op->ob_item[0] = (PyObject *) free_list[len]; numfree[len]++; diff --git a/Objects/typeobject.c b/Objects/typeobject.c index e51059b..cf749ef 100644 --- a/Objects/typeobject.c +++ b/Objects/typeobject.c @@ -5335,7 +5335,7 @@ PyType_Ready(PyTypeObject *type) NULL when type is &PyBaseObject_Type, and we know its ob_type is not NULL (it's initialized to &PyType_Type). But coverity doesn't know that. */ - if (Py_TYPE(type) == NULL && base != NULL) { + if (Py_IS_TYPE(type, NULL) && base != NULL) { Py_SET_TYPE(type, Py_TYPE(base)); } @@ -6645,7 +6645,7 @@ slot_tp_getattr_hook(PyObject *self, PyObject *name) needed, with call_attribute. */ getattribute = _PyType_LookupId(tp, &PyId___getattribute__); if (getattribute == NULL || - (Py_TYPE(getattribute) == &PyWrapperDescr_Type && + (Py_IS_TYPE(getattribute, &PyWrapperDescr_Type) && ((PyWrapperDescrObject *)getattribute)->d_wrapped == (void *)PyObject_GenericGetAttr)) res = PyObject_GenericGetAttr(self, name); @@ -7352,7 +7352,7 @@ update_one_slot(PyTypeObject *type, slotdef *p) } continue; } - if (Py_TYPE(descr) == &PyWrapperDescr_Type && + if (Py_IS_TYPE(descr, &PyWrapperDescr_Type) && ((PyWrapperDescrObject *)descr)->d_base->name_strobj == p->name_strobj) { void **tptr = resolve_slotdups(type, p->name_strobj); if (tptr == NULL || tptr == ptr) @@ -7375,7 +7375,7 @@ update_one_slot(PyTypeObject *type, slotdef *p) use_generic = 1; } } - else if (Py_TYPE(descr) == &PyCFunction_Type && + else if (Py_IS_TYPE(descr, &PyCFunction_Type) && PyCFunction_GET_FUNCTION(descr) == (PyCFunction)(void(*)(void))tp_new_wrapper && ptr == (void**)&type->tp_new) diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c index e0a666f..3d99f11 100644 --- a/Objects/unicodeobject.c +++ b/Objects/unicodeobject.c @@ -8484,7 +8484,7 @@ charmapencode_output(Py_UCS4 c, PyObject *mapping, char *outstart; Py_ssize_t outsize = PyBytes_GET_SIZE(*outobj); - if (Py_TYPE(mapping) == &EncodingMapType) { + if (Py_IS_TYPE(mapping, &EncodingMapType)) { int res = encoding_map_lookup(c, mapping); Py_ssize_t requiredsize = *outpos+1; if (res == -1) @@ -8563,7 +8563,7 @@ charmap_encoding_error( /* find all unencodable characters */ while (collendpos < size) { PyObject *rep; - if (Py_TYPE(mapping) == &EncodingMapType) { + if (Py_IS_TYPE(mapping, &EncodingMapType)) { ch = PyUnicode_READ_CHAR(unicode, collendpos); val = encoding_map_lookup(ch, mapping); if (val != -1) diff --git a/Python/ceval.c b/Python/ceval.c index 3f65820..ef4aac2 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -4851,7 +4851,7 @@ trace_call_function(PyThreadState *tstate, C_TRACE(x, PyObject_Vectorcall(func, args, nargs, kwnames)); return x; } - else if (Py_TYPE(func) == &PyMethodDescr_Type && nargs > 0) { + else if (Py_IS_TYPE(func, &PyMethodDescr_Type) && nargs > 0) { /* We need to create a temporary bound method as argument for profiling. @@ -4912,7 +4912,7 @@ do_call_core(PyThreadState *tstate, PyObject *func, PyObject *callargs, PyObject C_TRACE(result, PyObject_Call(func, callargs, kwdict)); return result; } - else if (Py_TYPE(func) == &PyMethodDescr_Type) { + else if (Py_IS_TYPE(func, &PyMethodDescr_Type)) { Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); if (nargs > 0 && tstate->use_tracing) { /* We need to create a temporary bound method as argument diff --git a/Python/errors.c b/Python/errors.c index 61dc597..6baa229 100644 --- a/Python/errors.c +++ b/Python/errors.c @@ -573,7 +573,7 @@ PyErr_BadArgument(void) PyObject * _PyErr_NoMemory(PyThreadState *tstate) { - if (Py_TYPE(PyExc_MemoryError) == NULL) { + if (Py_IS_TYPE(PyExc_MemoryError, NULL)) { /* PyErr_NoMemory() has been called before PyExc_MemoryError has been initialized by _PyExc_Init() */ Py_FatalError("Out of memory and PyExc_MemoryError is not " diff --git a/Python/importdl.c b/Python/importdl.c index 1d0d32a..fbeb9fb 100644 --- a/Python/importdl.c +++ b/Python/importdl.c @@ -181,7 +181,7 @@ _PyImport_LoadDynamicModuleWithSpec(PyObject *spec, FILE *fp) m = NULL; goto error; } - if (Py_TYPE(m) == NULL) { + if (Py_IS_TYPE(m, NULL)) { /* This can happen when a PyModuleDef is returned without calling * PyModuleDef_Init on it */ -- cgit v0.12