languages/cpython
languages/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython synced 2024-07-21 18:25:47 +00:00
Code Issues Actions 7 Packages Projects Releases Wiki Activity

gh-86493: Modernize modules initialization code (GH-106858)

Browse source 
Use PyModule_Add() or PyModule_AddObjectRef() instead of soft deprecated
PyModule_AddObject().
This commit is contained in:
Serhiy Storchaka 2023-07-25 14:34:49 +03:00 committed by GitHub
parent f443b54a2f
commit 329e4a1a3f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
29 changed files with 84 additions and 292 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
Doc/extending/extending.rst
View file

@ -221,9 +221,7 @@ with an exception object::
return NULL;
SpamError = PyErr_NewException("spam.error", NULL, NULL);
Py_XINCREF(SpamError);
if (PyModule_AddObject(m, "error", SpamError) < 0) {
Py_XDECREF(SpamError);
if (PyModule_AddObjectRef(m, "error", SpamError) < 0) {
Py_CLEAR(SpamError);
Py_DECREF(m);
return NULL;
@ -1281,8 +1279,7 @@ function must take care of initializing the C API pointer array::
/* Create a Capsule containing the API pointer array's address */
c_api_object = PyCapsule_New((void *)PySpam_API, "spam._C_API", NULL);
if (PyModule_AddObject(m, "_C_API", c_api_object) < 0) {
Py_XDECREF(c_api_object);
if (PyModule_Add(m, "_C_API", c_api_object) < 0) {
Py_DECREF(m);
return NULL;
}

8
Doc/extending/newtypes_tutorial.rst
View file

@ -180,9 +180,7 @@ This initializes the :class:`Custom` type, filling in a number of members
to the appropriate default values, including :attr:`ob_type` that we initially
set to ``NULL``. ::
Py_INCREF(&CustomType);
if (PyModule_AddObject(m, "Custom", (PyObject *) &CustomType) < 0) {
Py_DECREF(&CustomType);
if (PyModule_AddObjectRef(m, "Custom", (PyObject *) &CustomType) < 0) {
Py_DECREF(m);
return NULL;
}
@ -862,9 +860,7 @@ function::
if (m == NULL)
return NULL;
Py_INCREF(&SubListType);
if (PyModule_AddObject(m, "SubList", (PyObject *) &SubListType) < 0) {
Py_DECREF(&SubListType);
if (PyModule_AddObjectRef(m, "SubList", (PyObject *) &SubListType) < 0) {
Py_DECREF(m);
return NULL;
}

4
Doc/includes/custom.c
View file

@ -34,9 +34,7 @@ PyInit_custom(void)
if (m == NULL)
return NULL;
Py_INCREF(&CustomType);
if (PyModule_AddObject(m, "Custom", (PyObject *) &CustomType) < 0) {
Py_DECREF(&CustomType);
if (PyModule_AddObjectRef(m, "Custom", (PyObject *) &CustomType) < 0) {
Py_DECREF(m);
return NULL;
}

4
Doc/includes/sublist.c
View file

@ -58,9 +58,7 @@ PyInit_sublist(void)
if (m == NULL)
return NULL;
Py_INCREF(&SubListType);
if (PyModule_AddObject(m, "SubList", (PyObject *) &SubListType) < 0) {
Py_DECREF(&SubListType);
if (PyModule_AddObjectRef(m, "SubList", (PyObject *) &SubListType) < 0) {
Py_DECREF(m);
return NULL;
}

3
Modules/_datetimemodule.c
View file

@ -6834,8 +6834,7 @@ _datetime_exec(PyObject *module)
return -1;
}
if (PyModule_AddObject(module, "datetime_CAPI", x) < 0) {
Py_DECREF(x);
if (PyModule_Add(module, "datetime_CAPI", x) < 0) {
return -1;
}

5
Modules/_decimal/_decimal.c
View file

@ -6053,9 +6053,8 @@ PyInit__decimal(void)
/* Init mpd_ssize_t constants */
for (ssize_cm = ssize_constants; ssize_cm->name != NULL; ssize_cm++) {
ASSIGN_PTR(obj, PyLong_FromSsize_t(ssize_cm->val));
CHECK_INT(PyModule_AddObject(m, ssize_cm->name, obj));
obj = NULL;
CHECK_INT(PyModule_Add(m, ssize_cm->name,
PyLong_FromSsize_t(ssize_cm->val)));
}
/* Init int constants */

6
Modules/_gdbmmodule.c
View file

@ -787,11 +787,7 @@ _gdbm_exec(PyObject *module)
defined(GDBM_VERSION_PATCH)
PyObject *obj = Py_BuildValue("iii", GDBM_VERSION_MAJOR,
GDBM_VERSION_MINOR, GDBM_VERSION_PATCH);
if (obj == NULL) {
return -1;
}
if (PyModule_AddObject(module, "_GDBM_VERSION", obj) < 0) {
Py_DECREF(obj);
if (PyModule_Add(module, "_GDBM_VERSION", obj) < 0) {
return -1;
}
#endif

7
Modules/_hashopenssl.c
View file

@ -1889,12 +1889,7 @@ hashlib_md_meth_names(PyObject *module)
return -1;
}
if (PyModule_AddObject(module, "openssl_md_meth_names", state.set) < 0) {
Py_DECREF(state.set);
return -1;
}
return 0;
return PyModule_Add(module, "openssl_md_meth_names", state.set);
}
/*[clinic input]

4
Modules/_heapqmodule.c
View file

@ -672,9 +672,7 @@ From all times, sorting has always been a Great Art! :-)\n");
static int
heapq_exec(PyObject *m)
{
PyObject *about = PyUnicode_FromString(__about__);
if (PyModule_AddObject(m, "__about__", about) < 0) {
Py_DECREF(about);
if (PyModule_Add(m, "__about__", PyUnicode_FromString(__about__)) < 0) {
return -1;
}
return 0;

7
Modules/_localemodule.c
View file

@ -844,12 +844,7 @@ _locale_exec(PyObject *module)
_locale_state *state = get_locale_state(module);
state->Error = PyErr_NewException("locale.Error", NULL, NULL);
if (state->Error == NULL) {
return -1;
}
Py_INCREF(get_locale_state(module)->Error);
if (PyModule_AddObject(module, "Error", get_locale_state(module)->Error) < 0) {
Py_DECREF(get_locale_state(module)->Error);
if (PyModule_AddObjectRef(module, "Error", state->Error) < 0) {
return -1;
}

10
Modules/_lzmamodule.c
View file

@ -1498,15 +1498,7 @@ _lzma__decode_filter_properties_impl(PyObject *module, lzma_vli filter_id,
static int
module_add_int_constant(PyObject *m, const char *name, long long value)
{
PyObject *o = PyLong_FromLongLong(value);
if (o == NULL) {
return -1;
}
if (PyModule_AddObject(m, name, o) == 0) {
return 0;
}
Py_DECREF(o);
return -1;
return PyModule_Add(m, name, PyLong_FromLongLong(value));
}
static int

3
Modules/_multiprocessing/multiprocessing.c
View file

@ -266,8 +266,7 @@ multiprocessing_exec(PyObject *module)
ADD_FLAG(HAVE_BROKEN_SEM_UNLINK);
#endif
if (PyModule_AddObject(module, "flags", flags) < 0) {
Py_DECREF(flags);
if (PyModule_Add(module, "flags", flags) < 0) {
return -1;
}

2
Modules/_ssl.c
View file

@ -5986,7 +5986,7 @@ sslmodule_init_constants(PyObject *m)
#define addbool(m, key, value) \
do { \
PyObject *bool_obj = (value) ? Py_True : Py_False; \
PyModule_AddObject((m), (key), Py_NewRef(bool_obj)); \
PyModule_AddObjectRef((m), (key), bool_obj); \
} while (0)
addbool(m, "HAS_SNI", 1);

92
Modules/_testcapi/heaptype.c
View file

@ -1122,94 +1122,62 @@ _PyTestCapi_Init_Heaptype(PyObject *m) {
return -1;
}
#define ADD(name, value) do { \
if (PyModule_Add(m, name, value) < 0) { \
return -1; \
} \
} while (0)
PyObject *HeapDocCType = PyType_FromSpec(&HeapDocCType_spec);
if (HeapDocCType == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapDocCType", HeapDocCType);
ADD("HeapDocCType", HeapDocCType);
/* bpo-41832: Add a new type to test PyType_FromSpec()
now can accept a NULL tp_doc slot. */
PyObject *NullTpDocType = PyType_FromSpec(&NullTpDocType_spec);
if (NullTpDocType == NULL) {
return -1;
}
PyModule_AddObject(m, "NullTpDocType", NullTpDocType);
ADD("NullTpDocType", NullTpDocType);
PyObject *HeapGcCType = PyType_FromSpec(&HeapGcCType_spec);
if (HeapGcCType == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapGcCType", HeapGcCType);
ADD("HeapGcCType", HeapGcCType);
PyObject *HeapCType = PyType_FromSpec(&HeapCType_spec);
if (HeapCType == NULL) {
return -1;
}
PyObject *subclass_bases = PyTuple_Pack(1, HeapCType);
Py_DECREF(HeapCType);
if (subclass_bases == NULL) {
return -1;
}
PyObject *HeapCTypeSubclass = PyType_FromSpecWithBases(&HeapCTypeSubclass_spec, subclass_bases);
if (HeapCTypeSubclass == NULL) {
return -1;
}
Py_DECREF(subclass_bases);
PyModule_AddObject(m, "HeapCTypeSubclass", HeapCTypeSubclass);
ADD("HeapCTypeSubclass", HeapCTypeSubclass);
PyObject *HeapCTypeWithDict = PyType_FromSpec(&HeapCTypeWithDict_spec);
if (HeapCTypeWithDict == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeWithDict", HeapCTypeWithDict);
ADD("HeapCTypeWithDict", HeapCTypeWithDict);
PyObject *HeapCTypeWithDict2 = PyType_FromSpec(&HeapCTypeWithDict2_spec);
if (HeapCTypeWithDict2 == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeWithDict2", HeapCTypeWithDict2);
ADD("HeapCTypeWithDict2", HeapCTypeWithDict2);
PyObject *HeapCTypeWithNegativeDict = PyType_FromSpec(&HeapCTypeWithNegativeDict_spec);
if (HeapCTypeWithNegativeDict == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeWithNegativeDict", HeapCTypeWithNegativeDict);
ADD("HeapCTypeWithNegativeDict", HeapCTypeWithNegativeDict);
PyObject *HeapCTypeWithManagedDict = PyType_FromSpec(&HeapCTypeWithManagedDict_spec);
if (HeapCTypeWithManagedDict == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeWithManagedDict", HeapCTypeWithManagedDict);
ADD("HeapCTypeWithManagedDict", HeapCTypeWithManagedDict);
PyObject *HeapCTypeWithManagedWeakref = PyType_FromSpec(&HeapCTypeWithManagedWeakref_spec);
if (HeapCTypeWithManagedWeakref == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeWithManagedWeakref", HeapCTypeWithManagedWeakref);
ADD("HeapCTypeWithManagedWeakref", HeapCTypeWithManagedWeakref);
PyObject *HeapCTypeWithWeakref = PyType_FromSpec(&HeapCTypeWithWeakref_spec);
if (HeapCTypeWithWeakref == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeWithWeakref", HeapCTypeWithWeakref);
ADD("HeapCTypeWithWeakref", HeapCTypeWithWeakref);
PyObject *HeapCTypeWithWeakref2 = PyType_FromSpec(&HeapCTypeWithWeakref2_spec);
if (HeapCTypeWithWeakref2 == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeWithWeakref2", HeapCTypeWithWeakref2);
ADD("HeapCTypeWithWeakref2", HeapCTypeWithWeakref2);
PyObject *HeapCTypeWithBuffer = PyType_FromSpec(&HeapCTypeWithBuffer_spec);
if (HeapCTypeWithBuffer == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeWithBuffer", HeapCTypeWithBuffer);
ADD("HeapCTypeWithBuffer", HeapCTypeWithBuffer);
PyObject *HeapCTypeSetattr = PyType_FromSpec(&HeapCTypeSetattr_spec);
if (HeapCTypeSetattr == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeSetattr", HeapCTypeSetattr);
ADD("HeapCTypeSetattr", HeapCTypeSetattr);
PyObject *subclass_with_finalizer_bases = PyTuple_Pack(1, HeapCTypeSubclass);
if (subclass_with_finalizer_bases == NULL) {
@ -1217,32 +1185,20 @@ _PyTestCapi_Init_Heaptype(PyObject *m) {
}
PyObject *HeapCTypeSubclassWithFinalizer = PyType_FromSpecWithBases(
&HeapCTypeSubclassWithFinalizer_spec, subclass_with_finalizer_bases);
if (HeapCTypeSubclassWithFinalizer == NULL) {
return -1;
}
Py_DECREF(subclass_with_finalizer_bases);
PyModule_AddObject(m, "HeapCTypeSubclassWithFinalizer", HeapCTypeSubclassWithFinalizer);
ADD("HeapCTypeSubclassWithFinalizer", HeapCTypeSubclassWithFinalizer);
PyObject *HeapCTypeMetaclass = PyType_FromMetaclass(
&PyType_Type, m, &HeapCTypeMetaclass_spec, (PyObject *) &PyType_Type);
if (HeapCTypeMetaclass == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeMetaclass", HeapCTypeMetaclass);
ADD("HeapCTypeMetaclass", HeapCTypeMetaclass);
PyObject *HeapCTypeMetaclassCustomNew = PyType_FromMetaclass(
&PyType_Type, m, &HeapCTypeMetaclassCustomNew_spec, (PyObject *) &PyType_Type);
if (HeapCTypeMetaclassCustomNew == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeMetaclassCustomNew", HeapCTypeMetaclassCustomNew);
ADD("HeapCTypeMetaclassCustomNew", HeapCTypeMetaclassCustomNew);
PyObject *HeapCTypeMetaclassNullNew = PyType_FromMetaclass(
&PyType_Type, m, &HeapCTypeMetaclassNullNew_spec, (PyObject *) &PyType_Type);
if (HeapCTypeMetaclassNullNew == NULL) {
return -1;
}
PyModule_AddObject(m, "HeapCTypeMetaclassNullNew", HeapCTypeMetaclassNullNew);
ADD("HeapCTypeMetaclassNullNew", HeapCTypeMetaclassNullNew);
PyObject *HeapCCollection = PyType_FromMetaclass(
NULL, m, &HeapCCollection_spec, NULL);

24
Modules/_testmultiphase.c
View file

@ -383,32 +383,20 @@ static int execfunc(PyObject *m)
/* Add a custom type */
temp = PyType_FromSpec(&Example_Type_spec);
if (temp == NULL) {
goto fail;
}
if (PyModule_AddObject(m, "Example", temp) != 0) {
Py_DECREF(temp);
if (PyModule_Add(m, "Example", temp) != 0) {
goto fail;
}
/* Add an exception type */
temp = PyErr_NewException("_testimportexec.error", NULL, NULL);
if (temp == NULL) {
goto fail;
}
if (PyModule_AddObject(m, "error", temp) != 0) {
Py_DECREF(temp);
if (PyModule_Add(m, "error", temp) != 0) {
goto fail;
}
/* Add Str */
temp = PyType_FromSpec(&Str_Type_spec);
if (temp == NULL) {
goto fail;
}
if (PyModule_AddObject(m, "Str", temp) != 0) {
Py_DECREF(temp);
if (PyModule_Add(m, "Str", temp) != 0) {
goto fail;
}
@ -857,11 +845,7 @@ meth_state_access_exec(PyObject *m)
}
temp = PyType_FromModuleAndSpec(m, &StateAccessType_spec, NULL);
if (temp == NULL) {
return -1;
}
if (PyModule_AddObject(m, "StateAccessType", temp) != 0) {
Py_DECREF(temp);
if (PyModule_Add(m, "StateAccessType", temp) != 0) {
return -1;
}

42
Modules/_tkinter.c
View file

@ -3197,7 +3197,7 @@ static struct PyModuleDef _tkintermodule = {
PyMODINIT_FUNC
PyInit__tkinter(void)
{
PyObject *m, *uexe, *cexe, *o;
PyObject *m, *uexe, *cexe;
tcl_lock = PyThread_allocate_lock();
if (tcl_lock == NULL)
@ -3207,17 +3207,11 @@ PyInit__tkinter(void)
if (m == NULL)
return NULL;
o = PyErr_NewException("_tkinter.TclError", NULL, NULL);
if (o == NULL) {
Tkinter_TclError = PyErr_NewException("_tkinter.TclError", NULL, NULL);
if (PyModule_AddObjectRef(m, "TclError", Tkinter_TclError)) {
Py_DECREF(m);
return NULL;
}
if (PyModule_AddObject(m, "TclError", Py_NewRef(o))) {
Py_DECREF(o);
Py_DECREF(m);
return NULL;
}
Tkinter_TclError = o;
if (PyModule_AddIntConstant(m, "READABLE", TCL_READABLE)) {
Py_DECREF(m);
@ -3264,41 +3258,23 @@ PyInit__tkinter(void)
return NULL;
}
o = PyType_FromSpec(&Tkapp_Type_spec);
if (o == NULL) {
Tkapp_Type = PyType_FromSpec(&Tkapp_Type_spec);
if (PyModule_AddObjectRef(m, "TkappType", Tkapp_Type)) {
Py_DECREF(m);
return NULL;
}
if (PyModule_AddObject(m, "TkappType", o)) {
Py_DECREF(o);
Py_DECREF(m);
return NULL;
}
Tkapp_Type = o;
o = PyType_FromSpec(&Tktt_Type_spec);
if (o == NULL) {
Tktt_Type = PyType_FromSpec(&Tktt_Type_spec);
if (PyModule_AddObjectRef(m, "TkttType", Tktt_Type)) {
Py_DECREF(m);
return NULL;
}
if (PyModule_AddObject(m, "TkttType", o)) {
Py_DECREF(o);
Py_DECREF(m);
return NULL;
}
Tktt_Type = o;
o = PyType_FromSpec(&PyTclObject_Type_spec);
if (o == NULL) {
PyTclObject_Type = PyType_FromSpec(&PyTclObject_Type_spec);
if (PyModule_AddObjectRef(m, "Tcl_Obj", PyTclObject_Type)) {
Py_DECREF(m);
return NULL;
}
if (PyModule_AddObject(m, "Tcl_Obj", o)) {
Py_DECREF(o);
Py_DECREF(m);
return NULL;
}
PyTclObject_Type = o;
/* This helps the dynamic loader; in Unicode aware Tcl versions

16
Modules/_weakref.c
View file

@ -144,27 +144,19 @@ weakref_functions[] = {
static int
weakref_exec(PyObject *module)
{
Py_INCREF(&_PyWeakref_RefType);
if (PyModule_AddObject(module, "ref", (PyObject *) &_PyWeakref_RefType) < 0) {
Py_DECREF(&_PyWeakref_RefType);
if (PyModule_AddObjectRef(module, "ref", (PyObject *) &_PyWeakref_RefType) < 0) {
return -1;
}
Py_INCREF(&_PyWeakref_RefType);
if (PyModule_AddObject(module, "ReferenceType",
if (PyModule_AddObjectRef(module, "ReferenceType",
(PyObject *) &_PyWeakref_RefType) < 0) {
Py_DECREF(&_PyWeakref_RefType);
return -1;
}
Py_INCREF(&_PyWeakref_ProxyType);
if (PyModule_AddObject(module, "ProxyType",
if (PyModule_AddObjectRef(module, "ProxyType",
(PyObject *) &_PyWeakref_ProxyType) < 0) {
Py_DECREF(&_PyWeakref_ProxyType);
return -1;
}
Py_INCREF(&_PyWeakref_CallableProxyType);
if (PyModule_AddObject(module, "CallableProxyType",
if (PyModule_AddObjectRef(module, "CallableProxyType",
(PyObject *) &_PyWeakref_CallableProxyType) < 0) {
Py_DECREF(&_PyWeakref_CallableProxyType);
return -1;
}

8
Modules/arraymodule.c
View file

@ -3163,9 +3163,8 @@ array_modexec(PyObject *m)
CREATE_TYPE(m, state->ArrayIterType, &arrayiter_spec);
Py_SET_TYPE(state->ArrayIterType, &PyType_Type);
if (PyModule_AddObject(m, "ArrayType",
Py_NewRef((PyObject *)state->ArrayType)) < 0) {
Py_DECREF((PyObject *)state->ArrayType);
if (PyModule_AddObjectRef(m, "ArrayType",
(PyObject *)state->ArrayType) < 0) {
return -1;
}
@ -3193,8 +3192,7 @@ array_modexec(PyObject *m)
*p++ = (char)descr->typecode;
}
typecodes = PyUnicode_DecodeASCII(buffer, p - buffer, NULL);
if (PyModule_AddObject(m, "typecodes", typecodes) < 0) {
Py_XDECREF(typecodes);
if (PyModule_Add(m, "typecodes", typecodes) < 0) {
return -1;
}

20
Modules/binascii.c
View file

@ -1253,32 +1253,20 @@ static struct PyMethodDef binascii_module_methods[] = {
PyDoc_STRVAR(doc_binascii, "Conversion between binary data and ASCII");
static int
binascii_exec(PyObject *module) {
int result;
binascii_exec(PyObject *module)
{
binascii_state *state = PyModule_GetState(module);
if (state == NULL) {
return -1;
}
state->Error = PyErr_NewException("binascii.Error", PyExc_ValueError, NULL);
if (state->Error == NULL) {
return -1;
}
Py_INCREF(state->Error);
result = PyModule_AddObject(module, "Error", state->Error);
if (result == -1) {
Py_DECREF(state->Error);
if (PyModule_AddObjectRef(module, "Error", state->Error) < 0) {
return -1;
}
state->Incomplete = PyErr_NewException("binascii.Incomplete", NULL, NULL);
if (state->Incomplete == NULL) {
return -1;
}
Py_INCREF(state->Incomplete);
result = PyModule_AddObject(module, "Incomplete", state->Incomplete);
if (result == -1) {
Py_DECREF(state->Incomplete);
if (PyModule_AddObjectRef(module, "Incomplete", state->Incomplete) < 0) {
return -1;
}

6
Modules/cjkcodecs/cjkcodecs.h
View file

@ -398,11 +398,7 @@ register_maps(PyObject *module)
strcpy(mhname + sizeof("__map_") - 1, h->charset);
PyObject *capsule = PyCapsule_New((void *)h, MAP_CAPSULE, NULL);
if (capsule == NULL) {
return -1;
}
if (PyModule_AddObject(module, mhname, capsule) < 0) {
Py_DECREF(capsule);
if (PyModule_Add(module, mhname, capsule) < 0) {
return -1;
}
}

8
Modules/md5module.c
View file

@ -356,13 +356,7 @@ md5_exec(PyObject *m)
st->md5_type = (PyTypeObject *)PyType_FromModuleAndSpec(
m, &md5_type_spec, NULL);
if (st->md5_type == NULL) {
return -1;
}
Py_INCREF((PyObject *)st->md5_type);
if (PyModule_AddObject(m, "MD5Type", (PyObject *)st->md5_type) < 0) {
Py_DECREF(st->md5_type);
if (PyModule_AddObjectRef(m, "MD5Type", (PyObject *)st->md5_type) < 0) {
return -1;
}

4
Modules/mmapmodule.c
View file

@ -1579,9 +1579,7 @@ new_mmap_object(PyTypeObject *type, PyObject *args, PyObject *kwdict)
static int
mmap_exec(PyObject *module)
{
Py_INCREF(PyExc_OSError);
if (PyModule_AddObject(module, "error", PyExc_OSError) < 0) {
Py_DECREF(PyExc_OSError);
if (PyModule_AddObjectRef(module, "error", PyExc_OSError) < 0) {
return -1;
}

7
Modules/overlapped.c
View file

@ -1996,12 +1996,7 @@ static PyMethodDef overlapped_functions[] = {
#define WINAPI_CONSTANT(fmt, con) \
do { \
PyObject *value = Py_BuildValue(fmt, con); \
if (value == NULL) { \
return -1; \
} \
if (PyModule_AddObject(module, #con, value) < 0 ) { \
Py_DECREF(value); \
if (PyModule_Add(module, #con, Py_BuildValue(fmt, con)) < 0 ) { \
return -1; \
} \
} while (0)

14
Modules/pyexpat.c
View file

@ -1656,8 +1656,7 @@ add_submodule(PyObject *mod, const char *fullname)
Py_DECREF(mod_name);
/* gives away the reference to the submodule */
if (PyModule_AddObject(mod, name, submodule) < 0) {
Py_DECREF(submodule);
if (PyModule_Add(mod, name, submodule) < 0) {
return NULL;
}
@ -1887,10 +1886,7 @@ add_features(PyObject *mod)
goto error;
}
}
if (PyModule_AddObject(mod, "features", list) < 0) {
goto error;
}
return 0;
return PyModule_Add(mod, "features", list);
error:
Py_DECREF(list);
@ -1959,8 +1955,7 @@ pyexpat_exec(PyObject *mod)
info.major,
info.minor,
info.micro);
if (PyModule_AddObject(mod, "version_info", versionInfo) < 0) {
Py_DECREF(versionInfo);
if (PyModule_Add(mod, "version_info", versionInfo) < 0) {
return -1;
}
}
@ -2040,8 +2035,7 @@ pyexpat_exec(PyObject *mod)
return -1;
}
if (PyModule_AddObject(mod, "expat_CAPI", capi_object) < 0) {
Py_DECREF(capi_object);
if (PyModule_Add(mod, "expat_CAPI", capi_object) < 0) {
return -1;
}

11
Modules/resource.c
View file

@ -372,9 +372,7 @@ resource_exec(PyObject *module)
} while (0)
/* Add some symbolic constants to the module */
Py_INCREF(PyExc_OSError);
if (PyModule_AddObject(module, "error", PyExc_OSError) < 0) {
Py_DECREF(PyExc_OSError);
if (PyModule_AddObjectRef(module, "error", PyExc_OSError) < 0) {
return -1;
}
@ -502,12 +500,7 @@ resource_exec(PyObject *module)
{
v = PyLong_FromLong((long) RLIM_INFINITY);
}
if (!v) {
return -1;
}
if (PyModule_AddObject(module, "RLIM_INFINITY", v) < 0) {
Py_DECREF(v);
if (PyModule_Add(module, "RLIM_INFINITY", v) < 0) {
return -1;
}
return 0;

9
Modules/sha1module.c
View file

@ -357,16 +357,9 @@ _sha1_exec(PyObject *module)
st->sha1_type = (PyTypeObject *)PyType_FromModuleAndSpec(
module, &sha1_type_spec, NULL);
if (st->sha1_type == NULL) {
return -1;
}
Py_INCREF(st->sha1_type);
if (PyModule_AddObject(module,
if (PyModule_AddObjectRef(module,
"SHA1Type",
(PyObject *)st->sha1_type) < 0) {
Py_DECREF(st->sha1_type);
return -1;
}

7
Modules/termios.c
View file

@ -1232,12 +1232,7 @@ termios_exec(PyObject *mod)
struct constant *constant = termios_constants;
termiosmodulestate *state = get_termios_state(mod);
state->TermiosError = PyErr_NewException("termios.error", NULL, NULL);
if (state->TermiosError == NULL) {
return -1;
}
Py_INCREF(state->TermiosError);
if (PyModule_AddObject(mod, "error", state->TermiosError) < 0) {
Py_DECREF(state->TermiosError);
if (PyModule_AddObjectRef(mod, "error", state->TermiosError) < 0) {
return -1;
}

6
Modules/unicodedata.c
View file

@ -1487,11 +1487,7 @@ unicodedata_exec(PyObject *module)
v = new_previous_version(ucd_type, "3.2.0",
get_change_3_2_0, normalization_3_2_0);
Py_DECREF(ucd_type);
if (v == NULL) {
return -1;
}
if (PyModule_AddObject(module, "ucd_3_2_0", v) < 0) {
Py_DECREF(v);
if (PyModule_Add(module, "ucd_3_2_0", v) < 0) {
return -1;
}

32
Modules/zlibmodule.c
View file

@ -2030,17 +2030,11 @@ zlib_exec(PyObject *mod)
}
state->ZlibError = PyErr_NewException("zlib.error", NULL, NULL);
if (state->ZlibError == NULL) {
if (PyModule_AddObjectRef(mod, "error", state->ZlibError) < 0) {
return -1;
}
if (PyModule_AddObject(mod, "error", Py_NewRef(state->ZlibError)) < 0) {
Py_DECREF(state->ZlibError);
return -1;
}
if (PyModule_AddObject(mod, "_ZlibDecompressor",
Py_NewRef(state->ZlibDecompressorType)) < 0) {
Py_DECREF(state->ZlibDecompressorType);
if (PyModule_AddObjectRef(mod, "_ZlibDecompressor",
(PyObject *)state->ZlibDecompressorType) < 0) {
return -1;
}
@ -2082,26 +2076,14 @@ zlib_exec(PyObject *mod)
#ifdef Z_TREES // 1.2.3.4, only for inflate
ZLIB_ADD_INT_MACRO(Z_TREES);
#endif
PyObject *ver = PyUnicode_FromString(ZLIB_VERSION);
if (ver == NULL) {
if (PyModule_Add(mod, "ZLIB_VERSION",
PyUnicode_FromString(ZLIB_VERSION)) < 0) {
return -1;
}
if (PyModule_AddObject(mod, "ZLIB_VERSION", ver) < 0) {
Py_DECREF(ver);
if (PyModule_Add(mod, "ZLIB_RUNTIME_VERSION",
PyUnicode_FromString(zlibVersion())) < 0) {
return -1;
}
ver = PyUnicode_FromString(zlibVersion());
if (ver == NULL) {
return -1;
}
if (PyModule_AddObject(mod, "ZLIB_RUNTIME_VERSION", ver) < 0) {
Py_DECREF(ver);
return -1;
}
if (PyModule_AddStringConstant(mod, "__version__", "1.0") < 0) {
return -1;
}