mirror of
https://github.com/python/cpython
synced 2024-09-18 21:31:39 +00:00
gh-99300: Use Py_NewRef() in Modules/ directory (#99468)
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
GitHub
parent
9a7e9f9921
commit
c340cbb7f7
|
|
@ -459,8 +459,7 @@ state_init(SRE_STATE* state, PatternObject* pattern, PyObject* string,
|
|||
state->start = (void*) ((char*) ptr + start * state->charsize);
|
||||
state->end = (void*) ((char*) ptr + end * state->charsize);
|
||||
|
||||
Py_INCREF(string);
|
||||
state->string = string;
|
||||
state->string = Py_NewRef(string);
|
||||
state->pos = start;
|
||||
state->endpos = end;
|
||||
|
||||
|
|
@ -499,8 +498,7 @@ getslice(int isbytes, const void *ptr,
|
|||
if (isbytes) {
|
||||
if (PyBytes_CheckExact(string) &&
|
||||
start == 0 && end == PyBytes_GET_SIZE(string)) {
|
||||
Py_INCREF(string);
|
||||
return string;
|
||||
return Py_NewRef(string);
|
||||
}
|
||||
return PyBytes_FromStringAndSize(
|
||||
(const char *)ptr + start, end - start);
|
||||
|
|
@ -1089,8 +1087,7 @@ pattern_subx(_sremodulestate* module_state,
|
|||
|
||||
if (PyCallable_Check(ptemplate)) {
|
||||
/* sub/subn takes either a function or a template */
|
||||
filter = ptemplate;
|
||||
Py_INCREF(filter);
|
||||
filter = Py_NewRef(ptemplate);
|
||||
filter_type = CALLABLE;
|
||||
} else {
|
||||
/* if not callable, check if it's a literal string */
|
||||
|
|
@ -1109,8 +1106,7 @@ pattern_subx(_sremodulestate* module_state,
|
|||
if (view.buf)
|
||||
PyBuffer_Release(&view);
|
||||
if (literal) {
|
||||
filter = ptemplate;
|
||||
Py_INCREF(filter);
|
||||
filter = Py_NewRef(ptemplate);
|
||||
filter_type = LITERAL;
|
||||
} else {
|
||||
/* not a literal; hand it over to the template compiler */
|
||||
|
|
@ -1120,8 +1116,8 @@ pattern_subx(_sremodulestate* module_state,
|
|||
|
||||
assert(Py_TYPE(filter) == module_state->Template_Type);
|
||||
if (Py_SIZE(filter) == 0) {
|
||||
Py_INCREF(((TemplateObject *)filter)->literal);
|
||||
Py_SETREF(filter, ((TemplateObject *)filter)->literal);
|
||||
Py_SETREF(filter,
|
||||
Py_NewRef(((TemplateObject *)filter)->literal));
|
||||
filter_type = LITERAL;
|
||||
}
|
||||
else {
|
||||
|
|
@ -1195,8 +1191,7 @@ pattern_subx(_sremodulestate* module_state,
|
|||
goto error;
|
||||
} else {
|
||||
/* filter is literal string */
|
||||
item = filter;
|
||||
Py_INCREF(item);
|
||||
item = Py_NewRef(filter);
|
||||
}
|
||||
|
||||
/* add to list */
|
||||
|
|
@ -1317,8 +1312,7 @@ static PyObject *
|
|||
_sre_SRE_Pattern___copy___impl(PatternObject *self)
|
||||
/*[clinic end generated code: output=85dedc2db1bd8694 input=a730a59d863bc9f5]*/
|
||||
{
|
||||
Py_INCREF(self);
|
||||
return (PyObject *)self;
|
||||
return Py_NewRef(self);
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
|
|
@ -1333,8 +1327,7 @@ static PyObject *
|
|||
_sre_SRE_Pattern___deepcopy__(PatternObject *self, PyObject *memo)
|
||||
/*[clinic end generated code: output=2ad25679c1f1204a input=a465b1602f997bed]*/
|
||||
{
|
||||
Py_INCREF(self);
|
||||
return (PyObject *)self;
|
||||
return Py_NewRef(self);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
|
|
@ -1500,19 +1493,16 @@ _sre_compile_impl(PyObject *module, PyObject *pattern, int flags,
|
|||
PyBuffer_Release(&view);
|
||||
}
|
||||
|
||||
Py_INCREF(pattern);
|
||||
self->pattern = pattern;
|
||||
self->pattern = Py_NewRef(pattern);
|
||||
|
||||
self->flags = flags;
|
||||
|
||||
self->groups = groups;
|
||||
|
||||
if (PyDict_GET_SIZE(groupindex) > 0) {
|
||||
Py_INCREF(groupindex);
|
||||
self->groupindex = groupindex;
|
||||
self->groupindex = Py_NewRef(groupindex);
|
||||
if (PyTuple_GET_SIZE(indexgroup) > 0) {
|
||||
Py_INCREF(indexgroup);
|
||||
self->indexgroup = indexgroup;
|
||||
self->indexgroup = Py_NewRef(indexgroup);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1555,8 +1545,7 @@ _sre_template_impl(PyObject *module, PyObject *pattern, PyObject *template)
|
|||
if (!self)
|
||||
return NULL;
|
||||
self->chunks = 1 + 2*n;
|
||||
self->literal = PyList_GET_ITEM(template, 0);
|
||||
Py_INCREF(self->literal);
|
||||
self->literal = Py_NewRef(PyList_GET_ITEM(template, 0));
|
||||
for (Py_ssize_t i = 0; i < n; i++) {
|
||||
Py_ssize_t index = PyLong_AsSsize_t(PyList_GET_ITEM(template, 2*i+1));
|
||||
if (index == -1 && PyErr_Occurred()) {
|
||||
|
|
@ -1576,8 +1565,7 @@ _sre_template_impl(PyObject *module, PyObject *pattern, PyObject *template)
|
|||
literal = NULL;
|
||||
self->chunks--;
|
||||
}
|
||||
Py_XINCREF(literal);
|
||||
self->items[i].literal = literal;
|
||||
self->items[i].literal = Py_XNewRef(literal);
|
||||
}
|
||||
return (PyObject*) self;
|
||||
|
||||
|
|
@ -2128,8 +2116,7 @@ match_getslice_by_index(MatchObject* self, Py_ssize_t index, PyObject* def)
|
|||
|
||||
if (self->string == Py_None || self->mark[index] < 0) {
|
||||
/* return default value if the string or group is undefined */
|
||||
Py_INCREF(def);
|
||||
return def;
|
||||
return Py_NewRef(def);
|
||||
}
|
||||
|
||||
ptr = getstring(self->string, &length, &isbytes, &charsize, &view);
|
||||
|
|
@ -2448,8 +2435,7 @@ match_regs(MatchObject* self)
|
|||
PyTuple_SET_ITEM(regs, index, item);
|
||||
}
|
||||
|
||||
Py_INCREF(regs);
|
||||
self->regs = regs;
|
||||
self->regs = Py_NewRef(regs);
|
||||
|
||||
return regs;
|
||||
}
|
||||
|
|
@ -2463,8 +2449,7 @@ static PyObject *
|
|||
_sre_SRE_Match___copy___impl(MatchObject *self)
|
||||
/*[clinic end generated code: output=a779c5fc8b5b4eb4 input=3bb4d30b6baddb5b]*/
|
||||
{
|
||||
Py_INCREF(self);
|
||||
return (PyObject *)self;
|
||||
return Py_NewRef(self);
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
|
|
@ -2479,8 +2464,7 @@ static PyObject *
|
|||
_sre_SRE_Match___deepcopy__(MatchObject *self, PyObject *memo)
|
||||
/*[clinic end generated code: output=ba7cb46d655e4ee2 input=779d12a31c2c325e]*/
|
||||
{
|
||||
Py_INCREF(self);
|
||||
return (PyObject *)self;
|
||||
return Py_NewRef(self);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(match_doc,
|
||||
|
|
@ -2509,8 +2493,7 @@ match_lastgroup_get(MatchObject *self, void *Py_UNUSED(ignored))
|
|||
{
|
||||
PyObject *result = PyTuple_GET_ITEM(self->pattern->indexgroup,
|
||||
self->lastindex);
|
||||
Py_INCREF(result);
|
||||
return result;
|
||||
return Py_NewRef(result);
|
||||
}
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
|
@ -2519,8 +2502,7 @@ static PyObject *
|
|||
match_regs_get(MatchObject *self, void *Py_UNUSED(ignored))
|
||||
{
|
||||
if (self->regs) {
|
||||
Py_INCREF(self->regs);
|
||||
return self->regs;
|
||||
return Py_NewRef(self->regs);
|
||||
} else
|
||||
return match_regs(self);
|
||||
}
|
||||
|
|
@ -2564,11 +2546,9 @@ pattern_new_match(_sremodulestate* module_state,
|
|||
if (!match)
|
||||
return NULL;
|
||||
|
||||
Py_INCREF(pattern);
|
||||
match->pattern = pattern;
|
||||
match->pattern = (PatternObject*)Py_NewRef(pattern);
|
||||
|
||||
Py_INCREF(state->string);
|
||||
match->string = state->string;
|
||||
match->string = Py_NewRef(state->string);
|
||||
|
||||
match->regs = NULL;
|
||||
match->groups = pattern->groups+1;
|
||||
|
|
@ -2788,8 +2768,7 @@ pattern_scanner(_sremodulestate *module_state,
|
|||
return NULL;
|
||||
}
|
||||
|
||||
Py_INCREF(self);
|
||||
scanner->pattern = (PyObject*) self;
|
||||
scanner->pattern = Py_NewRef(self);
|
||||
|
||||
PyObject_GC_Track(scanner);
|
||||
return (PyObject*) scanner;
|
||||
|
|
@ -2834,8 +2813,7 @@ static PyObject *
|
|||
expand_template(TemplateObject *self, MatchObject *match)
|
||||
{
|
||||
if (Py_SIZE(self) == 0) {
|
||||
Py_INCREF(self->literal);
|
||||
return self->literal;
|
||||
return Py_NewRef(self->literal);
|
||||
}
|
||||
|
||||
PyObject *result = NULL;
|
||||
|
|
@ -2855,8 +2833,7 @@ expand_template(TemplateObject *self, MatchObject *match)
|
|||
out = &PyList_GET_ITEM(list, 0);
|
||||
}
|
||||
|
||||
Py_INCREF(self->literal);
|
||||
out[count++] = self->literal;
|
||||
out[count++] = Py_NewRef(self->literal);
|
||||
for (Py_ssize_t i = 0; i < Py_SIZE(self); i++) {
|
||||
Py_ssize_t index = self->items[i].index;
|
||||
if (index >= match->groups) {
|
||||
|
|
@ -2868,15 +2845,13 @@ expand_template(TemplateObject *self, MatchObject *match)
|
|||
goto cleanup;
|
||||
}
|
||||
if (item != Py_None) {
|
||||
Py_INCREF(item);
|
||||
out[count++] = item;
|
||||
out[count++] = Py_NewRef(item);
|
||||
}
|
||||
Py_DECREF(item);
|
||||
|
||||
PyObject *literal = self->items[i].literal;
|
||||
if (literal != NULL) {
|
||||
Py_INCREF(literal);
|
||||
out[count++] = literal;
|
||||
out[count++] = Py_NewRef(literal);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -415,8 +415,7 @@ static PyObject *
|
|||
SSLError_str(PyOSErrorObject *self)
|
||||
{
|
||||
if (self->strerror != NULL && PyUnicode_Check(self->strerror)) {
|
||||
Py_INCREF(self->strerror);
|
||||
return self->strerror;
|
||||
return Py_NewRef(self->strerror);
|
||||
}
|
||||
else
|
||||
return PyObject_Str(self->args);
|
||||
|
|
@ -500,8 +499,7 @@ fill_and_set_sslerror(_sslmodulestate *state,
|
|||
if (verify_str != NULL) {
|
||||
verify_obj = PyUnicode_FromString(verify_str);
|
||||
} else {
|
||||
verify_obj = Py_None;
|
||||
Py_INCREF(verify_obj);
|
||||
verify_obj = Py_NewRef(Py_None);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
@ -800,8 +798,7 @@ newPySSLSocket(PySSLContext *sslctx, PySocketSockObject *sock,
|
|||
|
||||
self->ssl = NULL;
|
||||
self->Socket = NULL;
|
||||
self->ctx = sslctx;
|
||||
Py_INCREF(sslctx);
|
||||
self->ctx = (PySSLContext*)Py_NewRef(sslctx);
|
||||
self->shutdown_seen_zero = 0;
|
||||
self->owner = NULL;
|
||||
self->server_hostname = NULL;
|
||||
|
|
@ -1026,8 +1023,7 @@ _asn1obj2py(_sslmodulestate *state, const ASN1_OBJECT *name, int no_name)
|
|||
}
|
||||
}
|
||||
if (!buflen && no_name) {
|
||||
Py_INCREF(Py_None);
|
||||
name_obj = Py_None;
|
||||
name_obj = Py_NewRef(Py_None);
|
||||
}
|
||||
else {
|
||||
name_obj = PyUnicode_FromStringAndSize(namebuf, buflen);
|
||||
|
|
@ -1876,8 +1872,7 @@ _ssl__SSLSocket_get_unverified_chain_impl(PySSLSocket *self)
|
|||
X509 *peer = SSL_get_peer_certificate(self->ssl);
|
||||
|
||||
if (peer == NULL) {
|
||||
peerobj = Py_None;
|
||||
Py_INCREF(peerobj);
|
||||
peerobj = Py_NewRef(Py_None);
|
||||
} else {
|
||||
/* consume X509 reference on success */
|
||||
peerobj = _PySSL_CertificateFromX509(self->ctx->state, peer, 0);
|
||||
|
|
@ -1907,8 +1902,7 @@ cipher_to_tuple(const SSL_CIPHER *cipher)
|
|||
|
||||
cipher_name = SSL_CIPHER_get_name(cipher);
|
||||
if (cipher_name == NULL) {
|
||||
Py_INCREF(Py_None);
|
||||
PyTuple_SET_ITEM(retval, 0, Py_None);
|
||||
PyTuple_SET_ITEM(retval, 0, Py_NewRef(Py_None));
|
||||
} else {
|
||||
v = PyUnicode_FromString(cipher_name);
|
||||
if (v == NULL)
|
||||
|
|
@ -1918,8 +1912,7 @@ cipher_to_tuple(const SSL_CIPHER *cipher)
|
|||
|
||||
cipher_protocol = SSL_CIPHER_get_version(cipher);
|
||||
if (cipher_protocol == NULL) {
|
||||
Py_INCREF(Py_None);
|
||||
PyTuple_SET_ITEM(retval, 1, Py_None);
|
||||
PyTuple_SET_ITEM(retval, 1, Py_NewRef(Py_None));
|
||||
} else {
|
||||
v = PyUnicode_FromString(cipher_protocol);
|
||||
if (v == NULL)
|
||||
|
|
@ -2103,16 +2096,14 @@ _ssl__SSLSocket_compression_impl(PySSLSocket *self)
|
|||
}
|
||||
|
||||
static PySSLContext *PySSL_get_context(PySSLSocket *self, void *closure) {
|
||||
Py_INCREF(self->ctx);
|
||||
return self->ctx;
|
||||
return (PySSLContext*)Py_NewRef(self->ctx);
|
||||
}
|
||||
|
||||
static int PySSL_set_context(PySSLSocket *self, PyObject *value,
|
||||
void *closure) {
|
||||
|
||||
if (PyObject_TypeCheck(value, self->ctx->state->PySSLContext_Type)) {
|
||||
Py_INCREF(value);
|
||||
Py_SETREF(self->ctx, (PySSLContext *)value);
|
||||
Py_SETREF(self->ctx, (PySSLContext *)Py_NewRef(value));
|
||||
SSL_set_SSL_CTX(self->ssl, self->ctx->ctx);
|
||||
/* Set SSL* internal msg_callback to state of new context's state */
|
||||
SSL_set_msg_callback(
|
||||
|
|
@ -2150,8 +2141,7 @@ PySSL_get_server_hostname(PySSLSocket *self, void *c)
|
|||
{
|
||||
if (self->server_hostname == NULL)
|
||||
Py_RETURN_NONE;
|
||||
Py_INCREF(self->server_hostname);
|
||||
return self->server_hostname;
|
||||
return Py_NewRef(self->server_hostname);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(PySSL_get_server_hostname_doc,
|
||||
|
|
@ -2166,8 +2156,7 @@ PySSL_get_owner(PySSLSocket *self, void *c)
|
|||
Py_RETURN_NONE;
|
||||
|
||||
owner = PyWeakref_GetObject(self->owner);
|
||||
Py_INCREF(owner);
|
||||
return owner;
|
||||
return Py_NewRef(owner);
|
||||
}
|
||||
|
||||
static int
|
||||
|
|
@ -2820,8 +2809,7 @@ PySSL_get_session(PySSLSocket *self, void *closure) {
|
|||
}
|
||||
|
||||
assert(self->ctx);
|
||||
pysess->ctx = self->ctx;
|
||||
Py_INCREF(pysess->ctx);
|
||||
pysess->ctx = (PySSLContext*)Py_NewRef(self->ctx);
|
||||
pysess->session = session;
|
||||
PyObject_GC_Track(pysess);
|
||||
return (PyObject *)pysess;
|
||||
|
|
@ -4459,8 +4447,7 @@ get_sni_callback(PySSLContext *self, void *c)
|
|||
if (cb == NULL) {
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
Py_INCREF(cb);
|
||||
return cb;
|
||||
return Py_NewRef(cb);
|
||||
}
|
||||
|
||||
static int
|
||||
|
|
@ -4482,8 +4469,7 @@ set_sni_callback(PySSLContext *self, PyObject *arg, void *c)
|
|||
"not a callable object");
|
||||
return -1;
|
||||
}
|
||||
Py_INCREF(arg);
|
||||
self->set_sni_cb = arg;
|
||||
self->set_sni_cb = Py_NewRef(arg);
|
||||
SSL_CTX_set_tlsext_servername_callback(self->ctx, _servername_callback);
|
||||
SSL_CTX_set_tlsext_servername_arg(self->ctx, self);
|
||||
}
|
||||
|
|
@ -5196,7 +5182,7 @@ _ssl_get_default_verify_paths_impl(PyObject *module)
|
|||
#define CONVERT(info, target) { \
|
||||
const char *tmp = (info); \
|
||||
target = NULL; \
|
||||
if (!tmp) { Py_INCREF(Py_None); target = Py_None; } \
|
||||
if (!tmp) { target = Py_NewRef(Py_None); } \
|
||||
else if ((target = PyUnicode_DecodeFSDefault(tmp)) == NULL) { \
|
||||
target = PyBytes_FromString(tmp); } \
|
||||
if (!target) goto error; \
|
||||
|
|
@ -5311,11 +5297,9 @@ certEncodingType(DWORD encodingType)
|
|||
}
|
||||
switch(encodingType) {
|
||||
case X509_ASN_ENCODING:
|
||||
Py_INCREF(x509_asn);
|
||||
return x509_asn;
|
||||
return Py_NewRef(x509_asn);
|
||||
case PKCS_7_ASN_ENCODING:
|
||||
Py_INCREF(pkcs_7_asn);
|
||||
return pkcs_7_asn;
|
||||
return Py_NewRef(pkcs_7_asn);
|
||||
default:
|
||||
return PyLong_FromLong(encodingType);
|
||||
}
|
||||
|
|
@ -5717,8 +5701,7 @@ sslmodule_init_socketapi(PyObject *module)
|
|||
if ((sockmod == NULL) || (sockmod->Sock_Type == NULL)) {
|
||||
return -1;
|
||||
}
|
||||
state->Sock_Type = sockmod->Sock_Type;
|
||||
Py_INCREF(state->Sock_Type);
|
||||
state->Sock_Type = (PyTypeObject*)Py_NewRef(sockmod->Sock_Type);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -5925,8 +5908,7 @@ sslmodule_init_constants(PyObject *m)
|
|||
#define addbool(m, key, value) \
|
||||
do { \
|
||||
PyObject *bool_obj = (value) ? Py_True : Py_False; \
|
||||
Py_INCREF(bool_obj); \
|
||||
PyModule_AddObject((m), (key), bool_obj); \
|
||||
PyModule_AddObject((m), (key), Py_NewRef(bool_obj)); \
|
||||
} while (0)
|
||||
|
||||
addbool(m, "HAS_SNI", 1);
|
||||
|
|
|
|||
|
|
@ -87,8 +87,7 @@ _PySSL_msg_callback(int write_p, int version, int content_type,
|
|||
static PyObject *
|
||||
_PySSLContext_get_msg_callback(PySSLContext *self, void *c) {
|
||||
if (self->msg_cb != NULL) {
|
||||
Py_INCREF(self->msg_cb);
|
||||
return self->msg_cb;
|
||||
return Py_NewRef(self->msg_cb);
|
||||
} else {
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
|
@ -107,8 +106,7 @@ _PySSLContext_set_msg_callback(PySSLContext *self, PyObject *arg, void *c) {
|
|||
"not a callable object");
|
||||
return -1;
|
||||
}
|
||||
Py_INCREF(arg);
|
||||
self->msg_cb = arg;
|
||||
self->msg_cb = Py_NewRef(arg);
|
||||
SSL_CTX_set_msg_callback(self->ctx, _PySSL_msg_callback);
|
||||
}
|
||||
return 0;
|
||||
|
|
@ -166,8 +164,7 @@ _PySSL_keylog_callback(const SSL *ssl, const char *line)
|
|||
static PyObject *
|
||||
_PySSLContext_get_keylog_filename(PySSLContext *self, void *c) {
|
||||
if (self->keylog_filename != NULL) {
|
||||
Py_INCREF(self->keylog_filename);
|
||||
return self->keylog_filename;
|
||||
return Py_NewRef(self->keylog_filename);
|
||||
} else {
|
||||
Py_RETURN_NONE;
|
||||
}
|
||||
|
|
@ -203,8 +200,7 @@ _PySSLContext_set_keylog_filename(PySSLContext *self, PyObject *arg, void *c) {
|
|||
"Can't malloc memory for keylog file");
|
||||
return -1;
|
||||
}
|
||||
Py_INCREF(arg);
|
||||
self->keylog_filename = arg;
|
||||
self->keylog_filename = Py_NewRef(arg);
|
||||
|
||||
/* Write a header for seekable, empty files (this excludes pipes). */
|
||||
PySSL_BEGIN_ALLOW_THREADS
|
||||
|
|
|
|||
|
|
@ -1829,8 +1829,7 @@ Struct_iter_unpack(PyStructObject *self, PyObject *buffer)
|
|||
Py_DECREF(iter);
|
||||
return NULL;
|
||||
}
|
||||
Py_INCREF(self);
|
||||
iter->so = self;
|
||||
iter->so = (PyStructObject*)Py_NewRef(self);
|
||||
iter->index = 0;
|
||||
return (PyObject *)iter;
|
||||
}
|
||||
|
|
@ -2178,8 +2177,7 @@ cache_struct_converter(PyObject *module, PyObject *fmt, PyStructObject **ptr)
|
|||
|
||||
s_object = PyDict_GetItemWithError(state->cache, fmt);
|
||||
if (s_object != NULL) {
|
||||
Py_INCREF(s_object);
|
||||
*ptr = (PyStructObject *)s_object;
|
||||
*ptr = (PyStructObject *)Py_NewRef(s_object);
|
||||
return Py_CLEANUP_SUPPORTED;
|
||||
}
|
||||
else if (PyErr_Occurred()) {
|
||||
|
|
|
|||
|
|
@ -784,16 +784,14 @@ PyTclObject_string(PyTclObject *self, void *ignored)
|
|||
if (!self->string)
|
||||
return NULL;
|
||||
}
|
||||
Py_INCREF(self->string);
|
||||
return self->string;
|
||||
return Py_NewRef(self->string);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
PyTclObject_str(PyTclObject *self)
|
||||
{
|
||||
if (self->string) {
|
||||
Py_INCREF(self->string);
|
||||
return self->string;
|
||||
return Py_NewRef(self->string);
|
||||
}
|
||||
/* XXX Could cache result if it is non-ASCII. */
|
||||
return unicodeFromTclObj(self->value);
|
||||
|
|
@ -1736,8 +1734,7 @@ SetVar(TkappObject *self, PyObject *args, int flags)
|
|||
if (!ok)
|
||||
Tkinter_Error(self);
|
||||
else {
|
||||
res = Py_None;
|
||||
Py_INCREF(res);
|
||||
res = Py_NewRef(Py_None);
|
||||
}
|
||||
LEAVE_OVERLAP_TCL
|
||||
break;
|
||||
|
|
@ -1755,8 +1752,7 @@ SetVar(TkappObject *self, PyObject *args, int flags)
|
|||
if (!ok)
|
||||
Tkinter_Error(self);
|
||||
else {
|
||||
res = Py_None;
|
||||
Py_INCREF(res);
|
||||
res = Py_NewRef(Py_None);
|
||||
}
|
||||
LEAVE_OVERLAP_TCL
|
||||
break;
|
||||
|
|
@ -1842,8 +1838,7 @@ UnsetVar(TkappObject *self, PyObject *args, int flags)
|
|||
if (code == TCL_ERROR)
|
||||
res = Tkinter_Error(self);
|
||||
else {
|
||||
Py_INCREF(Py_None);
|
||||
res = Py_None;
|
||||
res = Py_NewRef(Py_None);
|
||||
}
|
||||
LEAVE_OVERLAP_TCL
|
||||
return res;
|
||||
|
|
@ -1883,8 +1878,7 @@ _tkinter_tkapp_getint(TkappObject *self, PyObject *arg)
|
|||
PyObject *result;
|
||||
|
||||
if (PyLong_Check(arg)) {
|
||||
Py_INCREF(arg);
|
||||
return arg;
|
||||
return Py_NewRef(arg);
|
||||
}
|
||||
|
||||
if (PyTclObject_Check(arg)) {
|
||||
|
|
@ -1928,8 +1922,7 @@ _tkinter_tkapp_getdouble(TkappObject *self, PyObject *arg)
|
|||
double v;
|
||||
|
||||
if (PyFloat_Check(arg)) {
|
||||
Py_INCREF(arg);
|
||||
return arg;
|
||||
return Py_NewRef(arg);
|
||||
}
|
||||
|
||||
if (PyNumber_Check(arg)) {
|
||||
|
|
@ -2145,8 +2138,7 @@ _tkinter_tkapp_splitlist(TkappObject *self, PyObject *arg)
|
|||
return v;
|
||||
}
|
||||
if (PyTuple_Check(arg)) {
|
||||
Py_INCREF(arg);
|
||||
return arg;
|
||||
return Py_NewRef(arg);
|
||||
}
|
||||
if (PyList_Check(arg)) {
|
||||
return PySequence_Tuple(arg);
|
||||
|
|
@ -2322,10 +2314,8 @@ _tkinter_tkapp_createcommand_impl(TkappObject *self, const char *name,
|
|||
data = PyMem_NEW(PythonCmd_ClientData, 1);
|
||||
if (!data)
|
||||
return PyErr_NoMemory();
|
||||
Py_INCREF(self);
|
||||
Py_INCREF(func);
|
||||
data->self = (PyObject *) self;
|
||||
data->func = func;
|
||||
data->self = Py_NewRef(self);
|
||||
data->func = Py_NewRef(func);
|
||||
if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
|
||||
Tcl_Condition cond = NULL;
|
||||
CommandEvent *ev = (CommandEvent*)attemptckalloc(sizeof(CommandEvent));
|
||||
|
|
@ -2430,10 +2420,8 @@ NewFHCD(PyObject *func, PyObject *file, int id)
|
|||
FileHandler_ClientData *p;
|
||||
p = PyMem_NEW(FileHandler_ClientData, 1);
|
||||
if (p != NULL) {
|
||||
Py_XINCREF(func);
|
||||
Py_XINCREF(file);
|
||||
p->func = func;
|
||||
p->file = file;
|
||||
p->func = Py_XNewRef(func);
|
||||
p->file = Py_XNewRef(file);
|
||||
p->id = id;
|
||||
p->next = HeadFHCD;
|
||||
HeadFHCD = p;
|
||||
|
|
@ -2591,13 +2579,11 @@ Tktt_New(PyObject *func)
|
|||
if (v == NULL)
|
||||
return NULL;
|
||||
|
||||
Py_INCREF(func);
|
||||
v->token = NULL;
|
||||
v->func = func;
|
||||
v->func = Py_NewRef(func);
|
||||
|
||||
/* Extra reference, deleted when called or when handler is deleted */
|
||||
Py_INCREF(v);
|
||||
return v;
|
||||
return (TkttObject*)Py_NewRef(v);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -2940,9 +2926,8 @@ _flatten1(FlattenContext* context, PyObject* item, int depth)
|
|||
if (context->size + 1 > context->maxsize &&
|
||||
!_bump(context, 1))
|
||||
return 0;
|
||||
Py_INCREF(o);
|
||||
PyTuple_SET_ITEM(context->tuple,
|
||||
context->size++, o);
|
||||
context->size++, Py_NewRef(o));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
|
@ -3266,8 +3251,7 @@ PyInit__tkinter(void)
|
|||
Py_DECREF(m);
|
||||
return NULL;
|
||||
}
|
||||
Py_INCREF(o);
|
||||
if (PyModule_AddObject(m, "TclError", o)) {
|
||||
if (PyModule_AddObject(m, "TclError", Py_NewRef(o))) {
|
||||
Py_DECREF(o);
|
||||
Py_DECREF(m);
|
||||
return NULL;
|
||||
|
|
|
|||
|
|
@ -347,8 +347,8 @@ tracemalloc_get_frame(_PyInterpreterFrame *pyframe, frame_t *frame)
|
|||
else {
|
||||
/* tracemalloc_filenames is responsible to keep a reference
|
||||
to the filename */
|
||||
Py_INCREF(filename);
|
||||
if (_Py_hashtable_set(tracemalloc_filenames, filename, NULL) < 0) {
|
||||
if (_Py_hashtable_set(tracemalloc_filenames, Py_NewRef(filename),
|
||||
NULL) < 0) {
|
||||
Py_DECREF(filename);
|
||||
#ifdef TRACE_DEBUG
|
||||
tracemalloc_error("failed to intern the filename");
|
||||
|
|
@ -1085,8 +1085,7 @@ frame_to_pyobject(frame_t *frame)
|
|||
if (frame_obj == NULL)
|
||||
return NULL;
|
||||
|
||||
Py_INCREF(frame->filename);
|
||||
PyTuple_SET_ITEM(frame_obj, 0, frame->filename);
|
||||
PyTuple_SET_ITEM(frame_obj, 0, Py_NewRef(frame->filename));
|
||||
|
||||
lineno_obj = PyLong_FromUnsignedLong(frame->lineno);
|
||||
if (lineno_obj == NULL) {
|
||||
|
|
@ -1107,8 +1106,7 @@ traceback_to_pyobject(traceback_t *traceback, _Py_hashtable_t *intern_table)
|
|||
if (intern_table != NULL) {
|
||||
frames = _Py_hashtable_get(intern_table, (const void *)traceback);
|
||||
if (frames) {
|
||||
Py_INCREF(frames);
|
||||
return frames;
|
||||
return Py_NewRef(frames);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -23,8 +23,7 @@ static PyObject *
|
|||
_typing__idfunc(PyObject *module, PyObject *x)
|
||||
/*[clinic end generated code: output=63c38be4a6ec5f2c input=49f17284b43de451]*/
|
||||
{
|
||||
Py_INCREF(x);
|
||||
return x;
|
||||
return Py_NewRef(x);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -291,8 +291,7 @@ _winapi_Overlapped_getbuffer_impl(OverlappedObject *self)
|
|||
return NULL;
|
||||
}
|
||||
res = self->read_buffer ? self->read_buffer : Py_None;
|
||||
Py_INCREF(res);
|
||||
return res;
|
||||
return Py_NewRef(res);
|
||||
}
|
||||
|
||||
/*[clinic input]
|
||||
|
|
|
|||
|
|
@ -1722,8 +1722,7 @@ _channelid_shared(PyObject *obj, _PyCrossInterpreterData *data)
|
|||
xid->resolve = ((channelid *)obj)->resolve;
|
||||
|
||||
data->data = xid;
|
||||
Py_INCREF(obj);
|
||||
data->obj = obj;
|
||||
data->obj = Py_NewRef(obj);
|
||||
data->new_object = _channelid_from_xid;
|
||||
data->free = PyMem_Free;
|
||||
return 0;
|
||||
|
|
@ -2634,12 +2633,12 @@ PyInit__xxsubinterpreters(void)
|
|||
}
|
||||
|
||||
/* Add other types */
|
||||
Py_INCREF(&ChannelIDtype);
|
||||
if (PyDict_SetItemString(ns, "ChannelID", (PyObject *)&ChannelIDtype) != 0) {
|
||||
if (PyDict_SetItemString(ns, "ChannelID",
|
||||
Py_NewRef(&ChannelIDtype)) != 0) {
|
||||
return NULL;
|
||||
}
|
||||
Py_INCREF(&_PyInterpreterID_Type);
|
||||
if (PyDict_SetItemString(ns, "InterpreterID", (PyObject *)&_PyInterpreterID_Type) != 0) {
|
||||
if (PyDict_SetItemString(ns, "InterpreterID",
|
||||
Py_NewRef(&_PyInterpreterID_Type)) != 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -709,8 +709,7 @@ array_richcompare(PyObject *v, PyObject *w, int op)
|
|||
res = Py_False;
|
||||
else
|
||||
res = Py_True;
|
||||
Py_INCREF(res);
|
||||
return res;
|
||||
return Py_NewRef(res);
|
||||
}
|
||||
|
||||
if (va->ob_descr == wa->ob_descr && va->ob_descr->compareitems != NULL) {
|
||||
|
|
@ -733,8 +732,7 @@ array_richcompare(PyObject *v, PyObject *w, int op)
|
|||
default: return NULL; /* cannot happen */
|
||||
}
|
||||
PyObject *res = cmp ? Py_True : Py_False;
|
||||
Py_INCREF(res);
|
||||
return res;
|
||||
return Py_NewRef(res);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -778,18 +776,15 @@ array_richcompare(PyObject *v, PyObject *w, int op)
|
|||
res = Py_True;
|
||||
else
|
||||
res = Py_False;
|
||||
Py_INCREF(res);
|
||||
return res;
|
||||
return Py_NewRef(res);
|
||||
}
|
||||
|
||||
/* We have an item that differs. First, shortcuts for EQ/NE */
|
||||
if (op == Py_EQ) {
|
||||
Py_INCREF(Py_False);
|
||||
res = Py_False;
|
||||
res = Py_NewRef(Py_False);
|
||||
}
|
||||
else if (op == Py_NE) {
|
||||
Py_INCREF(Py_True);
|
||||
res = Py_True;
|
||||
res = Py_NewRef(Py_True);
|
||||
}
|
||||
else {
|
||||
/* Compare the final item again using the proper operator */
|
||||
|
|
@ -1060,8 +1055,7 @@ array_inplace_concat(arrayobject *self, PyObject *bb)
|
|||
}
|
||||
if (array_do_extend(state, self, bb) == -1)
|
||||
return NULL;
|
||||
Py_INCREF(self);
|
||||
return (PyObject *)self;
|
||||
return Py_NewRef(self);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
|
|
@ -1085,8 +1079,7 @@ array_inplace_repeat(arrayobject *self, Py_ssize_t n)
|
|||
|
||||
_PyBytes_Repeat(self->ob_item, n*size, self->ob_item, size);
|
||||
}
|
||||
Py_INCREF(self);
|
||||
return (PyObject *)self;
|
||||
return Py_NewRef(self);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1947,9 +1940,8 @@ make_array(PyTypeObject *arraytype, char typecode, PyObject *items)
|
|||
Py_DECREF(typecode_obj);
|
||||
return NULL;
|
||||
}
|
||||
Py_INCREF(items);
|
||||
PyTuple_SET_ITEM(new_args, 0, typecode_obj);
|
||||
PyTuple_SET_ITEM(new_args, 1, items);
|
||||
PyTuple_SET_ITEM(new_args, 1, Py_NewRef(items));
|
||||
|
||||
array_obj = array_new(arraytype, new_args, NULL);
|
||||
Py_DECREF(new_args);
|
||||
|
|
@ -2219,8 +2211,7 @@ array_array___reduce_ex___impl(arrayobject *self, PyTypeObject *cls,
|
|||
return NULL;
|
||||
}
|
||||
if (dict == NULL) {
|
||||
dict = Py_None;
|
||||
Py_INCREF(dict);
|
||||
dict = Py_NewRef(Py_None);
|
||||
}
|
||||
|
||||
mformat_code = typecode_to_mformat_code(typecode);
|
||||
|
|
@ -2572,8 +2563,7 @@ array_buffer_getbuf(arrayobject *self, Py_buffer *view, int flags)
|
|||
}
|
||||
|
||||
view->buf = (void *)self->ob_item;
|
||||
view->obj = (PyObject*)self;
|
||||
Py_INCREF(self);
|
||||
view->obj = Py_NewRef(self);
|
||||
if (view->buf == NULL)
|
||||
view->buf = (void *)emptybuf;
|
||||
view->len = Py_SIZE(self) * self->ob_descr->itemsize;
|
||||
|
|
@ -2885,8 +2875,7 @@ array_iter(arrayobject *ao)
|
|||
if (it == NULL)
|
||||
return NULL;
|
||||
|
||||
Py_INCREF(ao);
|
||||
it->ao = ao;
|
||||
it->ao = (arrayobject*)Py_NewRef(ao);
|
||||
it->index = 0;
|
||||
it->getitem = ao->ob_descr->getitem;
|
||||
PyObject_GC_Track(it);
|
||||
|
|
@ -3083,8 +3072,8 @@ array_modexec(PyObject *m)
|
|||
CREATE_TYPE(m, state->ArrayIterType, &arrayiter_spec);
|
||||
Py_SET_TYPE(state->ArrayIterType, &PyType_Type);
|
||||
|
||||
Py_INCREF((PyObject *)state->ArrayType);
|
||||
if (PyModule_AddObject(m, "ArrayType", (PyObject *)state->ArrayType) < 0) {
|
||||
if (PyModule_AddObject(m, "ArrayType",
|
||||
Py_NewRef((PyObject *)state->ArrayType)) < 0) {
|
||||
Py_DECREF((PyObject *)state->ArrayType);
|
||||
return -1;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue