Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

gh-99300: Use Py_NewRef() in Modules/ directory (#99469) 

Replace Py_INCREF() and Py_XINCREF() with Py_NewRef() and
Py_XNewRef() in test C files of the Modules/ directory.
This commit is contained in:
Victor Stinner 2022-11-14 16:21:23 +01:00 committed by GitHub
parent e3d4fed074
commit 3e2f7135e6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 66 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Modules/cjkcodecs/multibytecodec.c
View File

@ -141,8 +141,7 @@ codecctx_errors_get(MultibyteStatefulCodecContext *self, void *Py_UNUSED(ignored
else if (self->errors == ERROR_REPLACE)
errors = "replace";
else {
Py_INCREF(self->errors);
return self->errors;
return Py_NewRef(self->errors);
}
return PyUnicode_FromString(errors);
@ -341,8 +340,7 @@ multibytecodec_encerror(MultibyteCodec *codec,
goto errorexit;
}
else {
Py_INCREF(tobj);
retstr = tobj;
retstr = Py_NewRef(tobj);
}
assert(PyBytes_Check(retstr));
@ -786,11 +784,9 @@ encoder_encode_stateful(MultibyteStatefulEncoderContext *ctx,
if (ctx->pending) {
PyObject *inbuf_tmp;
Py_INCREF(ctx->pending);
origpending = ctx->pending;
origpending = Py_NewRef(ctx->pending);
Py_INCREF(ctx->pending);
inbuf_tmp = ctx->pending;
inbuf_tmp = Py_NewRef(ctx->pending);
PyUnicode_Append(&inbuf_tmp, unistr);
if (inbuf_tmp == NULL)
goto errorexit;
@ -800,8 +796,7 @@ encoder_encode_stateful(MultibyteStatefulEncoderContext *ctx,
else {
origpending = NULL;
Py_INCREF(unistr);
inbuf = unistr;
inbuf = Py_NewRef(unistr);
}
if (PyUnicode_READY(inbuf) < 0)
goto errorexit;
@ -1645,8 +1640,7 @@ mbstreamreader_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
}
self->codec = ((MultibyteCodecObject *)codec)->codec;
self->stream = stream;
Py_INCREF(stream);
self->stream = Py_NewRef(stream);
self->pendingsize = 0;
self->errors = internal_error_callback(errors);
if (self->errors == NULL)
@ -1869,8 +1863,7 @@ mbstreamwriter_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
}
self->codec = ((MultibyteCodecObject *)codec)->codec;
self->stream = stream;
Py_INCREF(stream);
self->stream = Py_NewRef(stream);
self->pending = NULL;
self->errors = internal_error_callback(errors);
if (self->errors == NULL)

3
Modules/gcmodule.c
View File

@ -1870,8 +1870,7 @@ gc_is_tracked(PyObject *module, PyObject *obj)
result = Py_True;
else
result = Py_False;
Py_INCREF(result);
return result;
return Py_NewRef(result);
}
/*[clinic input]

29
Modules/getpath.c
View File

@ -125,8 +125,7 @@ getpath_isabs(PyObject *Py_UNUSED(self), PyObject *args)
r = _Py_isabs(path) ? Py_True : Py_False;
PyMem_Free((void *)path);
}
Py_XINCREF(r);
return r;
return Py_XNewRef(r);
}
@ -153,11 +152,10 @@ getpath_hassuffix(PyObject *Py_UNUSED(self), PyObject *args)
wcscmp(&path[len - suffixLen], suffix) != 0
#endif
) {
r = Py_False;
r = Py_NewRef(Py_False);
} else {
r = Py_True;
r = Py_NewRef(Py_True);
}
Py_INCREF(r);
PyMem_Free((void *)suffix);
}
PyMem_Free((void *)path);
@ -187,8 +185,7 @@ getpath_isdir(PyObject *Py_UNUSED(self), PyObject *args)
#endif
PyMem_Free((void *)path);
}
Py_XINCREF(r);
return r;
return Py_XNewRef(r);
}
@ -213,8 +210,7 @@ getpath_isfile(PyObject *Py_UNUSED(self), PyObject *args)
#endif
PyMem_Free((void *)path);
}
Py_XINCREF(r);
return r;
return Py_XNewRef(r);
}
@ -247,8 +243,7 @@ getpath_isxfile(PyObject *Py_UNUSED(self), PyObject *args)
#endif
PyMem_Free((void *)path);
}
Py_XINCREF(r);
return r;
return Py_XNewRef(r);
}
@ -488,8 +483,7 @@ done:
goto done;
}
if (!S_ISLNK(st.st_mode)) {
Py_INCREF(pathobj);
r = pathobj;
r = Py_NewRef(pathobj);
goto done;
}
wchar_t resolved[MAXPATHLEN+1];
@ -504,8 +498,7 @@ done:
return r;
#endif
Py_INCREF(pathobj);
return pathobj;
return Py_NewRef(pathobj);
}
@ -591,8 +584,7 @@ wchar_to_dict(PyObject *dict, const char *key, const wchar_t *s)
return 0;
}
} else {
u = Py_None;
Py_INCREF(u);
u = Py_NewRef(Py_None);
}
r = PyDict_SetItemString(dict, key, u) == 0;
Py_DECREF(u);
@ -617,8 +609,7 @@ decode_to_dict(PyObject *dict, const char *key, const char *s)
return 0;
}
} else {
u = Py_None;
Py_INCREF(u);
u = Py_NewRef(Py_None);
}
r = PyDict_SetItemString(dict, key, u) == 0;
Py_DECREF(u);

6
Modules/mathmodule.c
View File

@ -2048,8 +2048,7 @@ factorial_odd_part(unsigned long n)
inner = PyLong_FromLong(1);
if (inner == NULL)
return NULL;
outer = inner;
Py_INCREF(outer);
outer = Py_NewRef(inner);
upper = 3;
for (i = _Py_bit_length(n) - 2; i >= 0; i--) {
@ -3521,8 +3520,7 @@ perm_comb(PyObject *n, unsigned long long k, int iscomb)
return PyLong_FromLong(1);
}
if (k == 1) {
Py_INCREF(n);
return n;
return Py_NewRef(n);
}
/* P(n, k) = P(n, j) * P(n-j, k-j) */

9
Modules/ossaudiodev.c
View File

@ -534,8 +534,7 @@ oss_close(oss_audio_t *self, PyObject *unused)
static PyObject *
oss_self(PyObject *self, PyObject *unused)
{
Py_INCREF(self);
return self;
return Py_NewRef(self);
}
static PyObject *
@ -1135,10 +1134,8 @@ PyInit_ossaudiodev(void)
NULL, NULL);
if (OSSAudioError) {
/* Each call to PyModule_AddObject decrefs it; compensate: */
Py_INCREF(OSSAudioError);
Py_INCREF(OSSAudioError);
PyModule_AddObject(m, "error", OSSAudioError);
PyModule_AddObject(m, "OSSAudioError", OSSAudioError);
PyModule_AddObject(m, "error", Py_NewRef(OSSAudioError));
PyModule_AddObject(m, "OSSAudioError", Py_NewRef(OSSAudioError));
}
/* Build 'control_labels' and 'control_names' lists and add them

12
Modules/overlapped.c
View File

@ -912,8 +912,7 @@ _overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait)
_PyBytes_Resize(&self->allocated_buffer, transferred))
return NULL;
Py_INCREF(self->allocated_buffer);
return self->allocated_buffer;
return Py_NewRef(self->allocated_buffer);
case TYPE_READ_FROM:
assert(PyBytes_CheckExact(self->read_from.allocated_buffer));
@ -940,14 +939,12 @@ _overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait)
}
// first item: message
Py_INCREF(self->read_from.allocated_buffer);
PyTuple_SET_ITEM(self->read_from.result, 0,
self->read_from.allocated_buffer);
Py_NewRef(self->read_from.allocated_buffer));
// second item: address
PyTuple_SET_ITEM(self->read_from.result, 1, addr);
Py_INCREF(self->read_from.result);
return self->read_from.result;
return Py_NewRef(self->read_from.result);
case TYPE_READ_FROM_INTO:
// unparse the address
addr = unparse_address((SOCKADDR*)&self->read_from_into.address,
@ -970,8 +967,7 @@ _overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait)
// second item: address
PyTuple_SET_ITEM(self->read_from_into.result, 1, addr);
Py_INCREF(self->read_from_into.result);
return self->read_from_into.result;
return Py_NewRef(self->read_from_into.result);
default:
return PyLong_FromUnsignedLong((unsigned long) transferred);
}

60
Modules/posixmodule.c
View File

@ -1221,8 +1221,7 @@ path_converter(PyObject *o, void *p)
#endif
}
else if (is_bytes) {
bytes = o;
Py_INCREF(bytes);
bytes = Py_NewRef(o);
}
else if (is_index) {
if (!_fd_converter(o, &path->fd)) {
@ -2240,8 +2239,7 @@ statresult_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
for (i = 7; i <= 9; i++) {
if (result->ob_item[i+3] == Py_None) {
Py_DECREF(Py_None);
Py_INCREF(result->ob_item[i]);
result->ob_item[i+3] = result->ob_item[i];
result->ob_item[i+3] = Py_NewRef(result->ob_item[i]);
}
}
return (PyObject*)result;
@ -6888,8 +6886,7 @@ os_sched_param_impl(PyTypeObject *type, PyObject *sched_priority)
res = PyStructSequence_New(type);
if (!res)
return NULL;
Py_INCREF(sched_priority);
PyStructSequence_SET_ITEM(res, 0, sched_priority);
PyStructSequence_SET_ITEM(res, 0, Py_NewRef(sched_priority));
return res;
}
@ -8017,8 +8014,7 @@ os_kill_impl(PyObject *module, pid_t pid, Py_ssize_t signal)
err = GetLastError();
result = PyErr_SetFromWindowsErr(err);
} else {
Py_INCREF(Py_None);
result = Py_None;
result = Py_NewRef(Py_None);
}
CloseHandle(handle);
@ -8647,7 +8643,7 @@ os_unshare_impl(PyObject *module, int flags)
if (res != 0) {
return posix_error();
}
Py_RETURN_NONE;
}
#endif
@ -13693,8 +13689,7 @@ DirEntry_get_lstat(PyTypeObject *defining_class, DirEntry *self)
self->lstat = DirEntry_fetch_stat(module, self, 0);
#endif
}
Py_XINCREF(self->lstat);
return self->lstat;
return Py_XNewRef(self->lstat);
}
/*[clinic input]
@ -13730,8 +13725,7 @@ os_DirEntry_stat_impl(DirEntry *self, PyTypeObject *defining_class,
}
}
Py_XINCREF(self->stat);
return self->stat;
return Py_XNewRef(self->stat);
}
/* Set exception and return -1 on error, 0 for False, 1 for True */
@ -13905,8 +13899,7 @@ static PyObject *
os_DirEntry___fspath___impl(DirEntry *self)
/*[clinic end generated code: output=6dd7f7ef752e6f4f input=3c49d0cf38df4fac]*/
{
Py_INCREF(self->path);
return self->path;
return Py_NewRef(self->path);
}
static PyMemberDef DirEntry_members[] = {
@ -14114,8 +14107,7 @@ DirEntry_from_posix_info(PyObject *module, path_t *path, const char *name,
goto error;
if (path->fd != -1) {
entry->path = entry->name;
Py_INCREF(entry->path);
entry->path = Py_NewRef(entry->name);
}
else if (!entry->path)
goto error;
@ -14306,8 +14298,7 @@ ScandirIterator_close(ScandirIterator *self, PyObject *args)
static PyObject *
ScandirIterator_enter(PyObject *self, PyObject *args)
{
Py_INCREF(self);
return self;
return Py_NewRef(self);
}
static PyObject *
@ -14515,8 +14506,7 @@ PyOS_FSPath(PyObject *path)
PyObject *path_repr = NULL;
if (PyUnicode_Check(path) || PyBytes_Check(path)) {
Py_INCREF(path);
return path;
return Py_NewRef(path);
}
func = _PyObject_LookupSpecial(path, &_Py_ID(__fspath__));
@ -15881,8 +15871,7 @@ posixmodule_exec(PyObject *m)
if (setup_confname_tables(m))
return -1;
Py_INCREF(PyExc_OSError);
PyModule_AddObject(m, "error", PyExc_OSError);
PyModule_AddObject(m, "error", Py_NewRef(PyExc_OSError));
#if defined(HAVE_WAITID) && !defined(__APPLE__)
waitid_result_desc.name = MODNAME ".waitid_result";
@ -15890,8 +15879,7 @@ posixmodule_exec(PyObject *m)
if (WaitidResultType == NULL) {
return -1;
}
Py_INCREF(WaitidResultType);
PyModule_AddObject(m, "waitid_result", WaitidResultType);
PyModule_AddObject(m, "waitid_result", Py_NewRef(WaitidResultType));
state->WaitidResultType = WaitidResultType;
#endif
@ -15903,8 +15891,7 @@ posixmodule_exec(PyObject *m)
if (StatResultType == NULL) {
return -1;
}
Py_INCREF(StatResultType);
PyModule_AddObject(m, "stat_result", StatResultType);
PyModule_AddObject(m, "stat_result", Py_NewRef(StatResultType));
state->StatResultType = StatResultType;
structseq_new = ((PyTypeObject *)StatResultType)->tp_new;
((PyTypeObject *)StatResultType)->tp_new = statresult_new;
@ -15914,8 +15901,7 @@ posixmodule_exec(PyObject *m)
if (StatVFSResultType == NULL) {
return -1;
}
Py_INCREF(StatVFSResultType);
PyModule_AddObject(m, "statvfs_result", StatVFSResultType);
PyModule_AddObject(m, "statvfs_result", Py_NewRef(StatVFSResultType));
state->StatVFSResultType = StatVFSResultType;
#ifdef NEED_TICKS_PER_SECOND
# if defined(HAVE_SYSCONF) && defined(_SC_CLK_TCK)
@ -15933,8 +15919,7 @@ posixmodule_exec(PyObject *m)
if (SchedParamType == NULL) {
return -1;
}
Py_INCREF(SchedParamType);
PyModule_AddObject(m, "sched_param", SchedParamType);
PyModule_AddObject(m, "sched_param", Py_NewRef(SchedParamType));
state->SchedParamType = SchedParamType;
((PyTypeObject *)SchedParamType)->tp_new = os_sched_param;
#endif
@ -15944,8 +15929,7 @@ posixmodule_exec(PyObject *m)
if (TerminalSizeType == NULL) {
return -1;
}
Py_INCREF(TerminalSizeType);
PyModule_AddObject(m, "terminal_size", TerminalSizeType);
PyModule_AddObject(m, "terminal_size", Py_NewRef(TerminalSizeType));
state->TerminalSizeType = TerminalSizeType;
/* initialize scandir types */
@ -15959,8 +15943,7 @@ posixmodule_exec(PyObject *m)
if (DirEntryType == NULL) {
return -1;
}
Py_INCREF(DirEntryType);
PyModule_AddObject(m, "DirEntry", DirEntryType);
PyModule_AddObject(m, "DirEntry", Py_NewRef(DirEntryType));
state->DirEntryType = DirEntryType;
times_result_desc.name = MODNAME ".times_result";
@ -15968,16 +15951,15 @@ posixmodule_exec(PyObject *m)
if (TimesResultType == NULL) {
return -1;
}
Py_INCREF(TimesResultType);
PyModule_AddObject(m, "times_result", TimesResultType);
PyModule_AddObject(m, "times_result", Py_NewRef(TimesResultType));
state->TimesResultType = TimesResultType;
PyTypeObject *UnameResultType = PyStructSequence_NewType(&uname_result_desc);
if (UnameResultType == NULL) {
return -1;
}
Py_INCREF(UnameResultType);
PyModule_AddObject(m, "uname_result", (PyObject *)UnameResultType);
;
PyModule_AddObject(m, "uname_result", Py_NewRef(UnameResultType));
state->UnameResultType = (PyObject *)UnameResultType;
if ((state->billion = PyLong_FromLong(1000000000)) == NULL)

18
Modules/pyexpat.c
View File

@ -959,8 +959,7 @@ pyexpat_xmlparser_ExternalEntityParserCreate_impl(xmlparseobject *self,
new_parser->itself = XML_ExternalEntityParserCreate(self->itself, context,
encoding);
new_parser->handlers = 0;
new_parser->intern = self->intern;
Py_XINCREF(new_parser->intern);
new_parser->intern = Py_XNewRef(self->intern);
if (self->buffer != NULL) {
new_parser->buffer = PyMem_Malloc(new_parser->buffer_size);
@ -991,8 +990,7 @@ pyexpat_xmlparser_ExternalEntityParserCreate_impl(xmlparseobject *self,
for (i = 0; handler_info[i].name != NULL; i++) {
PyObject *handler = self->handlers[i];
if (handler != NULL) {
Py_INCREF(handler);
new_parser->handlers[i] = handler;
new_parser->handlers[i] = Py_NewRef(handler);
handler_info[i].setter(new_parser->itself,
handler_info[i].handler);
}
@ -1148,8 +1146,7 @@ newxmlparseobject(pyexpat_state *state, const char *encoding,
self->in_callback = 0;
self->ns_prefixes = 0;
self->handlers = NULL;
self->intern = intern;
Py_XINCREF(self->intern);
self->intern = Py_XNewRef(intern);
/* namespace_separator is either NULL or contains one char + \0 */
self->itself = XML_ParserCreate_MM(encoding, &ExpatMemoryHandler,
@ -1232,8 +1229,7 @@ xmlparse_handler_getter(xmlparseobject *self, struct HandlerInfo *hi)
PyObject *result = self->handlers[handlernum];
if (result == NULL)
result = Py_None;
Py_INCREF(result);
return result;
return Py_NewRef(result);
}
static int
@ -1794,15 +1790,13 @@ add_errors_module(PyObject *mod)
goto error;
}
Py_INCREF(codes_dict);
if (PyModule_AddObject(errors_module, "codes", codes_dict) < 0) {
if (PyModule_AddObject(errors_module, "codes", Py_NewRef(codes_dict)) < 0) {
Py_DECREF(codes_dict);
goto error;
}
Py_CLEAR(codes_dict);
Py_INCREF(rev_codes_dict);
if (PyModule_AddObject(errors_module, "messages", rev_codes_dict) < 0) {
if (PyModule_AddObject(errors_module, "messages", Py_NewRef(rev_codes_dict)) < 0) {
Py_DECREF(rev_codes_dict);
goto error;
}

12
Modules/readline.c
View File

@ -402,8 +402,7 @@ set_hook(const char *funcname, PyObject **hook_var, PyObject *function)
Py_CLEAR(*hook_var);
}
else if (PyCallable_Check(function)) {
Py_INCREF(function);
Py_XSETREF(*hook_var, function);
Py_XSETREF(*hook_var, Py_NewRef(function));
}
else {
PyErr_Format(PyExc_TypeError,
@ -524,8 +523,7 @@ static PyObject *
readline_get_begidx_impl(PyObject *module)
/*[clinic end generated code: output=362616ee8ed1b2b1 input=e083b81c8eb4bac3]*/
{
Py_INCREF(readlinestate_global->begidx);
return readlinestate_global->begidx;
return Py_NewRef(readlinestate_global->begidx);
}
/* Get the ending index for the scope of the tab-completion */
@ -540,8 +538,7 @@ static PyObject *
readline_get_endidx_impl(PyObject *module)
/*[clinic end generated code: output=7f763350b12d7517 input=d4c7e34a625fd770]*/
{
Py_INCREF(readlinestate_global->endidx);
return readlinestate_global->endidx;
return Py_NewRef(readlinestate_global->endidx);
}
/* Set the tab-completion word-delimiters that readline uses */
@ -784,8 +781,7 @@ readline_get_completer_impl(PyObject *module)
if (readlinestate_global->completer == NULL) {
Py_RETURN_NONE;
}
Py_INCREF(readlinestate_global->completer);
return readlinestate_global->completer;
return Py_NewRef(readlinestate_global->completer);
}
/* Private function to get current length of history. XXX It may be

26
Modules/socketmodule.c
View File

@ -4110,8 +4110,7 @@ makeval_recvmsg(ssize_t received, void *data)
if (received < PyBytes_GET_SIZE(*buf))
_PyBytes_Resize(buf, received);
Py_XINCREF(*buf);
return *buf;
return Py_XNewRef(*buf);
}
/* s.recvmsg(bufsize[, ancbufsize[, flags]]) method */
@ -4390,8 +4389,7 @@ sock_sendall(PySocketSockObject *s, PyObject *args)
} while (len > 0);
PyBuffer_Release(&pbuf);
Py_INCREF(Py_None);
res = Py_None;
res = Py_NewRef(Py_None);
done:
PyBuffer_Release(&pbuf);
@ -7346,29 +7344,22 @@ PyInit__socket(void)
if (m == NULL)
return NULL;
Py_INCREF(PyExc_OSError);
PyModule_AddObject(m, "error", PyExc_OSError);
PyModule_AddObject(m, "error", Py_NewRef(PyExc_OSError));
socket_herror = PyErr_NewException("socket.herror",
PyExc_OSError, NULL);
if (socket_herror == NULL)
return NULL;
Py_INCREF(socket_herror);
PyModule_AddObject(m, "herror", socket_herror);
PyModule_AddObject(m, "herror", Py_NewRef(socket_herror));
socket_gaierror = PyErr_NewException("socket.gaierror", PyExc_OSError,
NULL);
if (socket_gaierror == NULL)
return NULL;
Py_INCREF(socket_gaierror);
PyModule_AddObject(m, "gaierror", socket_gaierror);
PyModule_AddObject(m, "gaierror", Py_NewRef(socket_gaierror));
PyModule_AddObjectRef(m, "timeout", PyExc_TimeoutError);
Py_INCREF((PyObject *)&sock_type);
if (PyModule_AddObject(m, "SocketType",
(PyObject *)&sock_type) != 0)
if (PyModule_AddObject(m, "SocketType", Py_NewRef(&sock_type)) != 0)
return NULL;
Py_INCREF((PyObject *)&sock_type);
if (PyModule_AddObject(m, "socket",
(PyObject *)&sock_type) != 0)
if (PyModule_AddObject(m, "socket", Py_NewRef(&sock_type)) != 0)
return NULL;
#ifdef ENABLE_IPV6
@ -7376,8 +7367,7 @@ PyInit__socket(void)
#else
has_ipv6 = Py_False;
#endif
Py_INCREF(has_ipv6);
PyModule_AddObject(m, "has_ipv6", has_ipv6);
PyModule_AddObject(m, "has_ipv6", Py_NewRef(has_ipv6));
/* Export C API */
PySocketModule_APIObject *capi = sock_get_api();