rather than a :c:expr:`PyObject*`.
+.. c:function:: int PyMapping_HasKeyWithError(PyObject *o, PyObject *key)
+
+ Return ``1`` if the mapping object has the key *key* and ``0`` otherwise.
+ This is equivalent to the Python expression ``key in o``.
+ On failure, return ``-1``.
+
+ .. versionadded:: 3.13
+
+
+.. c:function:: int PyMapping_HasKeyStringWithError(PyObject *o, const char *key)
+
+ This is the same as :c:func:`PyMapping_HasKeyWithError`, but *key* is
+ specified as a :c:expr:`const char*` UTF-8 encoded bytes string,
+ rather than a :c:expr:`PyObject*`.
+
+ .. versionadded:: 3.13
+
+
.. c:function:: int PyMapping_HasKey(PyObject *o, PyObject *key)
Return ``1`` if the mapping object has the key *key* and ``0`` otherwise.
Exceptions which occur when this calls :meth:`~object.__getitem__`
method are silently ignored.
- For proper error handling, use :c:func:`PyMapping_GetOptionalItem` or
- :c:func:`PyObject_GetItem()` instead.
+ For proper error handling, use :c:func:`PyMapping_HasKeyWithError`,
+ :c:func:`PyMapping_GetOptionalItem` or :c:func:`PyObject_GetItem()` instead.
.. c:function:: int PyMapping_HasKeyString(PyObject *o, const char *key)
Exceptions that occur when this calls :meth:`~object.__getitem__`
method or while creating the temporary :class:`str`
object are silently ignored.
- For proper error handling, use :c:func:`PyMapping_GetOptionalItemString` or
+ For proper error handling, use :c:func:`PyMapping_HasKeyStringWithError`,
+ :c:func:`PyMapping_GetOptionalItemString` or
:c:func:`PyMapping_GetItemString` instead.
instead of the :func:`repr`.
+.. c:function:: int PyObject_HasAttrWithError(PyObject *o, const char *attr_name)
+
+ Returns ``1`` if *o* has the attribute *attr_name*, and ``0`` otherwise.
+ This is equivalent to the Python expression ``hasattr(o, attr_name)``.
+ On failure, return ``-1``.
+
+ .. versionadded:: 3.13
+
+
+.. c:function:: int PyObject_HasAttrStringWithError(PyObject *o, const char *attr_name)
+
+ This is the same as :c:func:`PyObject_HasAttrWithError`, but *attr_name* is
+ specified as a :c:expr:`const char*` UTF-8 encoded bytes string,
+ rather than a :c:expr:`PyObject*`.
+
+ .. versionadded:: 3.13
+
+
.. c:function:: int PyObject_HasAttr(PyObject *o, PyObject *attr_name)
Returns ``1`` if *o* has the attribute *attr_name*, and ``0`` otherwise. This
Exceptions that occur when this calls :meth:`~object.__getattr__` and
:meth:`~object.__getattribute__` methods are silently ignored.
- For proper error handling, use :c:func:`PyObject_GetOptionalAttr` or
- :c:func:`PyObject_GetAttr` instead.
+ For proper error handling, use :c:func:`PyObject_HasAttrWithError`,
+ :c:func:`PyObject_GetOptionalAttr` or :c:func:`PyObject_GetAttr` instead.
.. c:function:: int PyObject_HasAttrString(PyObject *o, const char *attr_name)
Exceptions that occur when this calls :meth:`~object.__getattr__` and
:meth:`~object.__getattribute__` methods or while creating the temporary
:class:`str` object are silently ignored.
- For proper error handling, use :c:func:`PyObject_GetOptionalAttrString`
+ For proper error handling, use :c:func:`PyObject_HasAttrStringWithError`,
+ :c:func:`PyObject_GetOptionalAttrString`
or :c:func:`PyObject_GetAttrString` instead.
function,PyMapping_GetOptionalItemString,3.13,,
function,PyMapping_HasKey,3.2,,
function,PyMapping_HasKeyString,3.2,,
+function,PyMapping_HasKeyStringWithError,3.13,,
+function,PyMapping_HasKeyWithError,3.13,,
function,PyMapping_Items,3.2,,
function,PyMapping_Keys,3.2,,
function,PyMapping_Length,3.2,,
function,PyObject_GetTypeData,3.12,,
function,PyObject_HasAttr,3.2,,
function,PyObject_HasAttrString,3.2,,
+function,PyObject_HasAttrStringWithError,3.13,,
+function,PyObject_HasAttrWithError,3.13,,
function,PyObject_Hash,3.2,,
function,PyObject_HashNotImplemented,3.2,,
function,PyObject_Init,3.2,,
be treated as a failure.
(Contributed by Serhiy Storchaka in :gh:`106307`.)
+* Add fixed variants of functions which silently ignore errors:
+
+ - :c:func:`PyObject_HasAttrWithError` replaces :c:func:`PyObject_HasAttr`.
+ - :c:func:`PyObject_HasAttrStringWithError` replaces :c:func:`PyObject_HasAttrString`.
+ - :c:func:`PyMapping_HasKeyWithError` replaces :c:func:`PyMapping_HasKey`.
+ - :c:func:`PyMapping_HasKeyStringWithError` replaces :c:func:`PyMapping_HasKeyString`.
+
+ New functions return not only ``1`` for true and ``0`` for false, but also
+ ``-1`` for error.
+
+ (Contributed by Serhiy Storchaka in :gh:`108511`.)
+
* If Python is built in :ref:`debug mode <debug-build>` or :option:`with
assertions <--with-assertions>`, :c:func:`PyTuple_SET_ITEM` and
:c:func:`PyList_SET_ITEM` now check the index argument with an assertion.
This function always succeeds. */
+
+/* Implemented elsewhere:
+
+ int PyObject_HasAttrStringWithError(PyObject *o, const char *attr_name);
+
+ Returns 1 if object 'o' has the attribute attr_name, and 0 otherwise.
+ This is equivalent to the Python expression: hasattr(o,attr_name).
+ Returns -1 on failure. */
+
+
+/* Implemented elsewhere:
+
+ int PyObject_HasAttrWithError(PyObject *o, PyObject *attr_name);
+
+ Returns 1 if o has the attribute attr_name, and 0 otherwise.
+ This is equivalent to the Python expression: hasattr(o,attr_name).
+ Returns -1 on failure. */
+
+
/* Implemented elsewhere:
PyObject* PyObject_GetAttr(PyObject *o, PyObject *attr_name);
This function always succeeds. */
PyAPI_FUNC(int) PyMapping_HasKey(PyObject *o, PyObject *key);
+/* Return 1 if the mapping object has the key 'key', and 0 otherwise.
+ This is equivalent to the Python expression: key in o.
+ On failure, return -1. */
+
+PyAPI_FUNC(int) PyMapping_HasKeyWithError(PyObject *o, PyObject *key);
+
+/* Return 1 if the mapping object has the key 'key', and 0 otherwise.
+ This is equivalent to the Python expression: key in o.
+ On failure, return -1. */
+
+PyAPI_FUNC(int) PyMapping_HasKeyStringWithError(PyObject *o, const char *key);
+
/* On success, return a list or tuple of the keys in mapping object 'o'.
On failure, return NULL. */
PyAPI_FUNC(PyObject *) PyMapping_Keys(PyObject *o);
PyAPI_FUNC(int) PyObject_SetAttr(PyObject *, PyObject *, PyObject *);
PyAPI_FUNC(int) PyObject_DelAttr(PyObject *v, PyObject *name);
PyAPI_FUNC(int) PyObject_HasAttr(PyObject *, PyObject *);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d0000
+PyAPI_FUNC(int) PyObject_HasAttrWithError(PyObject *, PyObject *);
+PyAPI_FUNC(int) PyObject_HasAttrStringWithError(PyObject *, const char *);
+#endif
PyAPI_FUNC(PyObject *) PyObject_SelfIter(PyObject *);
PyAPI_FUNC(PyObject *) PyObject_GenericGetAttr(PyObject *, PyObject *);
PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *, PyObject *, PyObject *);
# CRASHES hasattrstring(obj, NULL)
# CRASHES hasattrstring(NULL, b'a')
+ def test_object_hasattrwitherror(self):
+ xhasattr = _testcapi.object_hasattrwitherror
+ obj = TestObject()
+ obj.a = 1
+ setattr(obj, '\U0001f40d', 2)
+ self.assertTrue(xhasattr(obj, 'a'))
+ self.assertFalse(xhasattr(obj, 'b'))
+ self.assertTrue(xhasattr(obj, '\U0001f40d'))
+
+ self.assertRaises(RuntimeError, xhasattr, obj, 'evil')
+ self.assertRaises(TypeError, xhasattr, obj, 1)
+ # CRASHES xhasattr(obj, NULL)
+ # CRASHES xhasattr(NULL, 'a')
+
+ def test_object_hasattrstringwitherror(self):
+ hasattrstring = _testcapi.object_hasattrstringwitherror
+ obj = TestObject()
+ obj.a = 1
+ setattr(obj, '\U0001f40d', 2)
+ self.assertTrue(hasattrstring(obj, b'a'))
+ self.assertFalse(hasattrstring(obj, b'b'))
+ self.assertTrue(hasattrstring(obj, '\U0001f40d'.encode()))
+
+ self.assertRaises(RuntimeError, hasattrstring, obj, b'evil')
+ self.assertRaises(UnicodeDecodeError, hasattrstring, obj, b'\xff')
+ # CRASHES hasattrstring(obj, NULL)
+ # CRASHES hasattrstring(NULL, b'a')
+
def test_object_setattr(self):
xsetattr = _testcapi.object_setattr
obj = TestObject()
self.assertFalse(haskeystring([], b'a'))
self.assertFalse(haskeystring(NULL, b'a'))
+ def test_mapping_haskeywitherror(self):
+ haskey = _testcapi.mapping_haskeywitherror
+ dct = {'a': 1, '\U0001f40d': 2}
+ self.assertTrue(haskey(dct, 'a'))
+ self.assertFalse(haskey(dct, 'b'))
+ self.assertTrue(haskey(dct, '\U0001f40d'))
+
+ dct2 = ProxyGetItem(dct)
+ self.assertTrue(haskey(dct2, 'a'))
+ self.assertFalse(haskey(dct2, 'b'))
+
+ self.assertTrue(haskey(['a', 'b', 'c'], 1))
+
+ self.assertRaises(TypeError, haskey, 42, 'a')
+ self.assertRaises(TypeError, haskey, {}, []) # unhashable
+ self.assertRaises(IndexError, haskey, [], 1)
+ self.assertRaises(TypeError, haskey, [], 'a')
+
+ # CRASHES haskey({}, NULL))
+ # CRASHES haskey(NULL, 'a'))
+
+ def test_mapping_haskeystringwitherror(self):
+ haskeystring = _testcapi.mapping_haskeystringwitherror
+ dct = {'a': 1, '\U0001f40d': 2}
+ self.assertTrue(haskeystring(dct, b'a'))
+ self.assertFalse(haskeystring(dct, b'b'))
+ self.assertTrue(haskeystring(dct, '\U0001f40d'.encode()))
+
+ dct2 = ProxyGetItem(dct)
+ self.assertTrue(haskeystring(dct2, b'a'))
+ self.assertFalse(haskeystring(dct2, b'b'))
+
+ self.assertRaises(TypeError, haskeystring, 42, b'a')
+ self.assertRaises(UnicodeDecodeError, haskeystring, {}, b'\xff')
+ self.assertRaises(SystemError, haskeystring, {}, NULL)
+ self.assertRaises(TypeError, haskeystring, [], b'a')
+ # CRASHES haskeystring(NULL, b'a')
+
def test_object_setitem(self):
setitem = _testcapi.object_setitem
dct = {}
"PyMapping_GetOptionalItemString",
"PyMapping_HasKey",
"PyMapping_HasKeyString",
+ "PyMapping_HasKeyStringWithError",
+ "PyMapping_HasKeyWithError",
"PyMapping_Items",
"PyMapping_Keys",
"PyMapping_Length",
"PyObject_GetTypeData",
"PyObject_HasAttr",
"PyObject_HasAttrString",
+ "PyObject_HasAttrStringWithError",
+ "PyObject_HasAttrWithError",
"PyObject_Hash",
"PyObject_HashNotImplemented",
"PyObject_Init",
--- /dev/null
+Add functions :c:func:`PyObject_HasAttrWithError`,
+:c:func:`PyObject_HasAttrStringWithError`,
+:c:func:`PyMapping_HasKeyWithError` and
+:c:func:`PyMapping_HasKeyStringWithError`.
added = '3.13'
[function.PyLong_AsInt]
added = '3.13'
+[function.PyObject_HasAttrWithError]
+ added = '3.13'
+[function.PyObject_HasAttrStringWithError]
+ added = '3.13'
+[function.PyMapping_HasKeyWithError]
+ added = '3.13'
+[function.PyMapping_HasKeyStringWithError]
+ added = '3.13'
if (fields == NULL)
return 0;
- if (PyObject_GetOptionalAttr(type, &_Py_ID(_swappedbytes_), &tmp) < 0) {
+ int rc = PyObject_HasAttrWithError(type, &_Py_ID(_swappedbytes_));
+ if (rc < 0) {
return -1;
}
- if (tmp) {
- Py_DECREF(tmp);
+ if (rc) {
big_endian = !PY_BIG_ENDIAN;
}
else {
sysid_obj, NULL);
Py_XDECREF(res);
}
- else if (PyObject_GetOptionalAttr((PyObject *)self, st->str_doctype, &res) > 0) {
+ else if (PyObject_HasAttrWithError((PyObject *)self, st->str_doctype) > 0) {
(void)PyErr_WarnEx(PyExc_RuntimeWarning,
"The doctype() method of XMLParser is ignored. "
"Define doctype() method on the TreeBuilder target.",
1);
- Py_DECREF(res);
}
Py_DECREF(doctype_name_obj);
static int
iobase_is_closed(PyObject *self)
{
- PyObject *res;
- int ret;
/* This gets the derived attribute, which is *not* __IOBase_closed
in most cases! */
- ret = PyObject_GetOptionalAttr(self, &_Py_ID(__IOBase_closed), &res);
- Py_XDECREF(res);
- return ret;
+ return PyObject_HasAttrWithError(self, &_Py_ID(__IOBase_closed));
}
/* Flush and close methods */
goto error;
self->seekable = self->telling = r;
- r = PyObject_GetOptionalAttr(buffer, &_Py_ID(read1), &res);
+ r = PyObject_HasAttrWithError(buffer, &_Py_ID(read1));
if (r < 0) {
goto error;
}
- Py_XDECREF(res);
self->has_read1 = r;
self->encoding_start_of_stream = 0;
into a newly created tuple. */
assert(PyTuple_Check(args));
if (!PyTuple_GET_SIZE(args) && PyType_Check(cls)) {
- PyObject *func;
- if (PyObject_GetOptionalAttr(cls, &_Py_ID(__getinitargs__), &func) < 0) {
+ int rc = PyObject_HasAttrWithError(cls, &_Py_ID(__getinitargs__));
+ if (rc < 0) {
return NULL;
}
- if (func == NULL) {
+ if (!rc) {
return PyObject_CallMethodOneArg(cls, &_Py_ID(__new__), cls);
}
- Py_DECREF(func);
}
return PyObject_CallObject(cls, args);
}
return PyLong_FromLong(PyObject_HasAttrString(obj, attr_name));
}
+static PyObject *
+object_hasattrwitherror(PyObject *self, PyObject *args)
+{
+ PyObject *obj, *attr_name;
+ if (!PyArg_ParseTuple(args, "OO", &obj, &attr_name)) {
+ return NULL;
+ }
+ NULLABLE(obj);
+ NULLABLE(attr_name);
+ RETURN_INT(PyObject_HasAttrWithError(obj, attr_name));
+}
+
+static PyObject *
+object_hasattrstringwitherror(PyObject *self, PyObject *args)
+{
+ PyObject *obj;
+ const char *attr_name;
+ Py_ssize_t size;
+ if (!PyArg_ParseTuple(args, "Oz#", &obj, &attr_name, &size)) {
+ return NULL;
+ }
+ NULLABLE(obj);
+ RETURN_INT(PyObject_HasAttrStringWithError(obj, attr_name));
+}
+
static PyObject *
object_setattr(PyObject *self, PyObject *args)
{
return PyLong_FromLong(PyMapping_HasKeyString(mapping, key));
}
+static PyObject *
+mapping_haskeywitherror(PyObject *self, PyObject *args)
+{
+ PyObject *mapping, *key;
+ if (!PyArg_ParseTuple(args, "OO", &mapping, &key)) {
+ return NULL;
+ }
+ NULLABLE(mapping);
+ NULLABLE(key);
+ RETURN_INT(PyMapping_HasKeyWithError(mapping, key));
+}
+
+static PyObject *
+mapping_haskeystringwitherror(PyObject *self, PyObject *args)
+{
+ PyObject *mapping;
+ const char *key;
+ Py_ssize_t size;
+ if (!PyArg_ParseTuple(args, "Oz#", &mapping, &key, &size)) {
+ return NULL;
+ }
+ NULLABLE(mapping);
+ RETURN_INT(PyMapping_HasKeyStringWithError(mapping, key));
+}
+
static PyObject *
object_setitem(PyObject *self, PyObject *args)
{
{"object_getoptionalattrstring", object_getoptionalattrstring, METH_VARARGS},
{"object_hasattr", object_hasattr, METH_VARARGS},
{"object_hasattrstring", object_hasattrstring, METH_VARARGS},
+ {"object_hasattrwitherror", object_hasattrwitherror, METH_VARARGS},
+ {"object_hasattrstringwitherror", object_hasattrstringwitherror, METH_VARARGS},
{"object_setattr", object_setattr, METH_VARARGS},
{"object_setattrstring", object_setattrstring, METH_VARARGS},
{"object_delattr", object_delattr, METH_VARARGS},
{"mapping_getoptionalitemstring", mapping_getoptionalitemstring, METH_VARARGS},
{"mapping_haskey", mapping_haskey, METH_VARARGS},
{"mapping_haskeystring", mapping_haskeystring, METH_VARARGS},
+ {"mapping_haskeywitherror", mapping_haskeywitherror, METH_VARARGS},
+ {"mapping_haskeystringwitherror", mapping_haskeystringwitherror, METH_VARARGS},
{"object_setitem", object_setitem, METH_VARARGS},
{"mapping_setitemstring", mapping_setitemstring, METH_VARARGS},
{"object_delitem", object_delitem, METH_VARARGS},
static PyObject *
add_new_exception(PyObject *mod, const char *name, PyObject *base)
{
- assert(!PyObject_HasAttrString(mod, name));
+ assert(!PyObject_HasAttrStringWithError(mod, name));
PyObject *exctype = PyErr_NewException(name, base, NULL);
if (exctype == NULL) {
return NULL;
static PyObject *
add_new_exception(PyObject *mod, const char *name, PyObject *base)
{
- assert(!PyObject_HasAttrString(mod, name));
+ assert(!PyObject_HasAttrStringWithError(mod, name));
PyObject *exctype = PyErr_NewException(name, base, NULL);
if (exctype == NULL) {
return NULL;
return r;
}
+int
+PyMapping_HasKeyStringWithError(PyObject *obj, const char *key)
+{
+ PyObject *res;
+ int rc = PyMapping_GetOptionalItemString(obj, key, &res);
+ Py_XDECREF(res);
+ return rc;
+}
+
+int
+PyMapping_HasKeyWithError(PyObject *obj, PyObject *key)
+{
+ PyObject *res;
+ int rc = PyMapping_GetOptionalItem(obj, key, &res);
+ Py_XDECREF(res);
+ return rc;
+}
+
int
PyMapping_HasKeyString(PyObject *o, const char *key)
{
if (PyDict_CheckExact(arg)) {
return PyDict_Merge(self, arg, 1);
}
- PyObject *func;
- if (PyObject_GetOptionalAttr(arg, &_Py_ID(keys), &func) < 0) {
+ int has_keys = PyObject_HasAttrWithError(arg, &_Py_ID(keys));
+ if (has_keys < 0) {
return -1;
}
- if (func != NULL) {
- Py_DECREF(func);
+ if (has_keys) {
return PyDict_Merge(self, arg, 1);
}
return PyDict_MergeFromSeq2(self, arg, 1);
PyObject *qualname = NULL;
PyObject *module = NULL;
PyObject *r = NULL;
- PyObject *tmp;
- int err;
+ int rc;
if (p == Py_Ellipsis) {
// The Ellipsis object
goto done;
}
- if (PyObject_GetOptionalAttr(p, &_Py_ID(__origin__), &tmp) < 0) {
- goto done;
+ if ((rc = PyObject_HasAttrWithError(p, &_Py_ID(__origin__))) > 0 &&
+ (rc = PyObject_HasAttrWithError(p, &_Py_ID(__args__))) > 0)
+ {
+ // It looks like a GenericAlias
+ goto use_repr;
}
- if (tmp != NULL) {
- Py_DECREF(tmp);
- if (PyObject_GetOptionalAttr(p, &_Py_ID(__args__), &tmp) < 0) {
- goto done;
- }
- if (tmp != NULL) {
- Py_DECREF(tmp);
- // It looks like a GenericAlias
- goto use_repr;
- }
+ if (rc < 0) {
+ goto done;
}
if (PyObject_GetOptionalAttr(p, &_Py_ID(__qualname__), &qualname) < 0) {
Py_XDECREF(module);
if (r == NULL) {
// error if any of the above PyObject_Repr/PyUnicode_From* fail
- err = -1;
+ rc = -1;
}
else {
- err = _PyUnicodeWriter_WriteStr(writer, r);
+ rc = _PyUnicodeWriter_WriteStr(writer, r);
Py_DECREF(r);
}
- return err;
+ return rc;
}
static int
Py_ssize_t iparam = 0;
for (Py_ssize_t iarg = 0; iarg < nargs; iarg++) {
PyObject *t = PyTuple_GET_ITEM(args, iarg);
- PyObject *subst;
// We don't want __parameters__ descriptor of a bare Python class.
if (PyType_Check(t)) {
continue;
}
- if (PyObject_GetOptionalAttr(t, &_Py_ID(__typing_subst__), &subst) < 0) {
+ int rc = PyObject_HasAttrWithError(t, &_Py_ID(__typing_subst__));
+ if (rc < 0) {
Py_DECREF(parameters);
return NULL;
}
- if (subst) {
+ if (rc) {
iparam += tuple_add(parameters, iparam, t);
- Py_DECREF(subst);
}
else {
PyObject *subparams;
}
int
-PyObject_HasAttrString(PyObject *v, const char *name)
+PyObject_HasAttrStringWithError(PyObject *obj, const char *name)
{
- if (Py_TYPE(v)->tp_getattr != NULL) {
- PyObject *res = (*Py_TYPE(v)->tp_getattr)(v, (char*)name);
- if (res != NULL) {
- Py_DECREF(res);
- return 1;
- }
- PyErr_Clear();
- return 0;
- }
+ PyObject *res;
+ int rc = PyObject_GetOptionalAttrString(obj, name, &res);
+ Py_XDECREF(res);
+ return rc;
+}
+
- PyObject *attr_name = PyUnicode_FromString(name);
- if (attr_name == NULL) {
+int
+PyObject_HasAttrString(PyObject *obj, const char *name)
+{
+ int rc = PyObject_HasAttrStringWithError(obj, name);
+ if (rc < 0) {
PyErr_Clear();
return 0;
}
- int ok = PyObject_HasAttr(v, attr_name);
- Py_DECREF(attr_name);
- return ok;
+ return rc;
}
int
}
int
-PyObject_HasAttr(PyObject *v, PyObject *name)
+PyObject_HasAttrWithError(PyObject *obj, PyObject *name)
{
PyObject *res;
- if (PyObject_GetOptionalAttr(v, name, &res) < 0) {
+ int rc = PyObject_GetOptionalAttr(obj, name, &res);
+ Py_XDECREF(res);
+ return rc;
+}
+
+int
+PyObject_HasAttr(PyObject *obj, PyObject *name)
+{
+ int rc = PyObject_HasAttrWithError(obj, name);
+ if (rc < 0) {
PyErr_Clear();
return 0;
}
- if (res == NULL) {
- return 0;
- }
- Py_DECREF(res);
- return 1;
+ return rc;
}
int
if (PyType_Check(base)) {
continue;
}
- PyObject *mro_entries;
- if (PyObject_GetOptionalAttr(base, &_Py_ID(__mro_entries__),
- &mro_entries) < 0) {
+ int rc = PyObject_HasAttrWithError(base, &_Py_ID(__mro_entries__));
+ if (rc < 0) {
return -1;
}
- if (mro_entries != NULL) {
+ if (rc) {
PyErr_SetString(PyExc_TypeError,
"type() doesn't support MRO entry resolution; "
"use types.new_class()");
- Py_DECREF(mro_entries);
return -1;
}
}
{
PyObject *qualname = NULL;
PyObject *module = NULL;
- PyObject *tmp;
PyObject *r = NULL;
- int err;
+ int rc;
if (p == (PyObject *)&_PyNone_Type) {
return _PyUnicodeWriter_WriteASCIIString(writer, "None", 4);
}
- if (PyObject_GetOptionalAttr(p, &_Py_ID(__origin__), &tmp) < 0) {
- goto exit;
+ if ((rc = PyObject_HasAttrWithError(p, &_Py_ID(__origin__))) > 0 &&
+ (rc = PyObject_HasAttrWithError(p, &_Py_ID(__args__))) > 0)
+ {
+ // It looks like a GenericAlias
+ goto use_repr;
}
-
- if (tmp) {
- Py_DECREF(tmp);
- if (PyObject_GetOptionalAttr(p, &_Py_ID(__args__), &tmp) < 0) {
- goto exit;
- }
- if (tmp) {
- // It looks like a GenericAlias
- Py_DECREF(tmp);
- goto use_repr;
- }
+ if (rc < 0) {
+ goto exit;
}
if (PyObject_GetOptionalAttr(p, &_Py_ID(__qualname__), &qualname) < 0) {
if (r == NULL) {
return -1;
}
- err = _PyUnicodeWriter_WriteStr(writer, r);
+ rc = _PyUnicodeWriter_WriteStr(writer, r);
Py_DECREF(r);
- return err;
+ return rc;
}
static PyObject *
EXPORT_FUNC(PyMapping_GetOptionalItemString)
EXPORT_FUNC(PyMapping_HasKey)
EXPORT_FUNC(PyMapping_HasKeyString)
+EXPORT_FUNC(PyMapping_HasKeyStringWithError)
+EXPORT_FUNC(PyMapping_HasKeyWithError)
EXPORT_FUNC(PyMapping_Items)
EXPORT_FUNC(PyMapping_Keys)
EXPORT_FUNC(PyMapping_Length)
EXPORT_FUNC(PyObject_GetTypeData)
EXPORT_FUNC(PyObject_HasAttr)
EXPORT_FUNC(PyObject_HasAttrString)
+EXPORT_FUNC(PyObject_HasAttrStringWithError)
+EXPORT_FUNC(PyObject_HasAttrWithError)
EXPORT_FUNC(PyObject_Hash)
EXPORT_FUNC(PyObject_HashNotImplemented)
EXPORT_FUNC(PyObject_Init)
}
}
if ((PyObject *)Py_TYPE(exc) != PyExc_SyntaxError) {
- if (PyObject_GetOptionalAttr(exc, &_Py_ID(msg), &tmp) < 0) {
+ int rc = PyObject_HasAttrWithError(exc, &_Py_ID(msg));
+ if (rc < 0) {
_PyErr_Clear(tstate);
}
- else if (tmp) {
- Py_DECREF(tmp);
- }
- else {
+ else if (!rc) {
tmp = PyObject_Str(exc);
if (tmp) {
if (PyObject_SetAttr(exc, &_Py_ID(msg), tmp)) {
}
}
- if (PyObject_GetOptionalAttr(exc, &_Py_ID(print_file_and_line), &tmp) < 0) {
+ rc = PyObject_HasAttrWithError(exc, &_Py_ID(print_file_and_line));
+ if (rc < 0) {
_PyErr_Clear(tstate);
}
- else if (tmp) {
- Py_DECREF(tmp);
- }
- else {
+ else if (!rc) {
if (PyObject_SetAttr(exc, &_Py_ID(print_file_and_line), Py_None)) {
_PyErr_Clear(tstate);
}
}
}
else {
- PyObject *path;
- if (PyObject_GetOptionalAttr(mod, &_Py_ID(__path__), &path) < 0) {
+ int has_path = PyObject_HasAttrWithError(mod, &_Py_ID(__path__));
+ if (has_path < 0) {
goto error;
}
- if (path) {
- Py_DECREF(path);
+ if (has_path) {
final_mod = PyObject_CallMethodObjArgs(
IMPORTLIB(interp), &_Py_ID(_handle_fromlist),
mod, fromlist, IMPORT_FUNC(interp), NULL);
goto error;
}
- PyObject *value;
- res = PyObject_GetOptionalAttr(self, name, &value);
+ res = PyObject_HasAttrWithError(self, name);
Py_DECREF(locals);
if (res < 0) {
goto error;
}
- if (value) {
- Py_DECREF(value);
+ if (res) {
Py_DECREF(dir);
return PyUnicode_FromFormat("self.%U", name);
}
projects / thirdparty / Python / cpython.git / commitdiff
