languages/cpython
languages/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython synced 2024-10-02 23:49:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

gh-99300: Use Py_NewRef() in Python/ directory (#99317)

Browse source 
Replace Py_INCREF() and Py_XINCREF() with Py_NewRef() and
Py_XNewRef() in C files of the Python/ directory.

Update Parser/asdl_c.py to regenerate Python/Python-ast.c.
This commit is contained in:
Victor Stinner 2022-11-10 11:23:36 +01:00 committed by GitHub
parent d8f239d86e
commit 231d83b724
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 169 additions and 327 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
Parser/asdl_c.py
View file

@ -995,10 +995,11 @@ def visitModule(self, mod):
static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), void *o)
{
if (!o)
o = Py_None;
Py_INCREF((PyObject*)o);
return (PyObject*)o;
PyObject *op = (PyObject*)o;
if (!op) {
op = Py_None;
}
return Py_NewRef(op);
}
#define ast2obj_constant ast2obj_object
#define ast2obj_identifier ast2obj_object
@ -1032,8 +1033,7 @@ def visitModule(self, mod):
*out = NULL;
return -1;
}
Py_INCREF(obj);
*out = obj;
*out = Py_NewRef(obj);
return 0;
}
@ -1301,8 +1301,7 @@ def simpleSum(self, sum, name):
self.emit("switch(o) {", 1)
for t in sum.types:
self.emit("case %s:" % t.name, 2)
self.emit("Py_INCREF(state->%s_singleton);" % t.name, 3)
self.emit("return state->%s_singleton;" % t.name, 3)
self.emit("return Py_NewRef(state->%s_singleton);" % t.name, 3)
self.emit("}", 1)
self.emit("Py_UNREACHABLE();", 1);
self.emit("}", 0)

108
Python/Python-ast.c generated
View file

@ -993,10 +993,11 @@ static PyObject* ast2obj_list(struct ast_state *state, asdl_seq *seq, PyObject*
static PyObject* ast2obj_object(struct ast_state *Py_UNUSED(state), void *o)
{
if (!o)
o = Py_None;
Py_INCREF((PyObject*)o);
return (PyObject*)o;
PyObject *op = (PyObject*)o;
if (!op) {
op = Py_None;
}
return Py_NewRef(op);
}
#define ast2obj_constant ast2obj_object
#define ast2obj_identifier ast2obj_object
@ -1030,8 +1031,7 @@ static int obj2ast_constant(struct ast_state *Py_UNUSED(state), PyObject* obj, P
*out = NULL;
return -1;
}
Py_INCREF(obj);
*out = obj;
*out = Py_NewRef(obj);
return 0;
}
@ -4732,14 +4732,11 @@ PyObject* ast2obj_expr_context(struct ast_state *state, expr_context_ty o)
{
switch(o) {
case Load:
Py_INCREF(state->Load_singleton);
return state->Load_singleton;
return Py_NewRef(state->Load_singleton);
case Store:
Py_INCREF(state->Store_singleton);
return state->Store_singleton;
return Py_NewRef(state->Store_singleton);
case Del:
Py_INCREF(state->Del_singleton);
return state->Del_singleton;
return Py_NewRef(state->Del_singleton);
}
Py_UNREACHABLE();
}
@ -4747,11 +4744,9 @@ PyObject* ast2obj_boolop(struct ast_state *state, boolop_ty o)
{
switch(o) {
case And:
Py_INCREF(state->And_singleton);
return state->And_singleton;
return Py_NewRef(state->And_singleton);
case Or:
Py_INCREF(state->Or_singleton);
return state->Or_singleton;
return Py_NewRef(state->Or_singleton);
}
Py_UNREACHABLE();
}
@ -4759,44 +4754,31 @@ PyObject* ast2obj_operator(struct ast_state *state, operator_ty o)
{
switch(o) {
case Add:
Py_INCREF(state->Add_singleton);
return state->Add_singleton;
return Py_NewRef(state->Add_singleton);
case Sub:
Py_INCREF(state->Sub_singleton);
return state->Sub_singleton;
return Py_NewRef(state->Sub_singleton);
case Mult:
Py_INCREF(state->Mult_singleton);
return state->Mult_singleton;
return Py_NewRef(state->Mult_singleton);
case MatMult:
Py_INCREF(state->MatMult_singleton);
return state->MatMult_singleton;
return Py_NewRef(state->MatMult_singleton);
case Div:
Py_INCREF(state->Div_singleton);
return state->Div_singleton;
return Py_NewRef(state->Div_singleton);
case Mod:
Py_INCREF(state->Mod_singleton);
return state->Mod_singleton;
return Py_NewRef(state->Mod_singleton);
case Pow:
Py_INCREF(state->Pow_singleton);
return state->Pow_singleton;
return Py_NewRef(state->Pow_singleton);
case LShift:
Py_INCREF(state->LShift_singleton);
return state->LShift_singleton;
return Py_NewRef(state->LShift_singleton);
case RShift:
Py_INCREF(state->RShift_singleton);
return state->RShift_singleton;
return Py_NewRef(state->RShift_singleton);
case BitOr:
Py_INCREF(state->BitOr_singleton);
return state->BitOr_singleton;
return Py_NewRef(state->BitOr_singleton);
case BitXor:
Py_INCREF(state->BitXor_singleton);
return state->BitXor_singleton;
return Py_NewRef(state->BitXor_singleton);
case BitAnd:
Py_INCREF(state->BitAnd_singleton);
return state->BitAnd_singleton;
return Py_NewRef(state->BitAnd_singleton);
case FloorDiv:
Py_INCREF(state->FloorDiv_singleton);
return state->FloorDiv_singleton;
return Py_NewRef(state->FloorDiv_singleton);
}
Py_UNREACHABLE();
}
@ -4804,17 +4786,13 @@ PyObject* ast2obj_unaryop(struct ast_state *state, unaryop_ty o)
{
switch(o) {
case Invert:
Py_INCREF(state->Invert_singleton);
return state->Invert_singleton;
return Py_NewRef(state->Invert_singleton);
case Not:
Py_INCREF(state->Not_singleton);
return state->Not_singleton;
return Py_NewRef(state->Not_singleton);
case UAdd:
Py_INCREF(state->UAdd_singleton);
return state->UAdd_singleton;
return Py_NewRef(state->UAdd_singleton);
case USub:
Py_INCREF(state->USub_singleton);
return state->USub_singleton;
return Py_NewRef(state->USub_singleton);
}
Py_UNREACHABLE();
}
@ -4822,35 +4800,25 @@ PyObject* ast2obj_cmpop(struct ast_state *state, cmpop_ty o)
{
switch(o) {
case Eq:
Py_INCREF(state->Eq_singleton);
return state->Eq_singleton;
return Py_NewRef(state->Eq_singleton);
case NotEq:
Py_INCREF(state->NotEq_singleton);
return state->NotEq_singleton;
return Py_NewRef(state->NotEq_singleton);
case Lt:
Py_INCREF(state->Lt_singleton);
return state->Lt_singleton;
return Py_NewRef(state->Lt_singleton);
case LtE:
Py_INCREF(state->LtE_singleton);
return state->LtE_singleton;
return Py_NewRef(state->LtE_singleton);
case Gt:
Py_INCREF(state->Gt_singleton);
return state->Gt_singleton;
return Py_NewRef(state->Gt_singleton);
case GtE:
Py_INCREF(state->GtE_singleton);
return state->GtE_singleton;
return Py_NewRef(state->GtE_singleton);
case Is:
Py_INCREF(state->Is_singleton);
return state->Is_singleton;
return Py_NewRef(state->Is_singleton);
case IsNot:
Py_INCREF(state->IsNot_singleton);
return state->IsNot_singleton;
return Py_NewRef(state->IsNot_singleton);
case In:
Py_INCREF(state->In_singleton);
return state->In_singleton;
return Py_NewRef(state->In_singleton);
case NotIn:
Py_INCREF(state->NotIn_singleton);
return state->NotIn_singleton;
return Py_NewRef(state->NotIn_singleton);
}
Py_UNREACHABLE();
}

36
Python/bltinmodule.c
View file

@ -63,8 +63,7 @@ update_bases(PyObject *bases, PyObject *const *args, Py_ssize_t nargs)
}
for (j = 0; j < i; j++) {
base = args[j];
PyList_SET_ITEM(new_bases, j, base);
Py_INCREF(base);
PyList_SET_ITEM(new_bases, j, Py_NewRef(base));
}
}
j = PyList_GET_SIZE(new_bases);
@ -170,8 +169,7 @@ builtin___build_class__(PyObject *self, PyObject *const *args, Py_ssize_t nargs,
}
if (winner != meta) {
Py_DECREF(meta);
meta = winner;
Py_INCREF(meta);
meta = Py_NewRef(winner);
}
}
/* else: meta is not a class, so we cannot do the metaclass
@ -804,8 +802,7 @@ builtin_compile_impl(PyObject *module, PyObject *source, PyObject *filename,
goto error;
if (is_ast) {
if (flags & PyCF_ONLY_AST) {
Py_INCREF(source);
result = source;
result = Py_NewRef(source);
}
else {
PyArena *arena;
@ -1128,8 +1125,7 @@ builtin_getattr(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
if (nargs > 2) {
if (_PyObject_LookupAttr(v, name, &result) == 0) {
PyObject *dflt = args[2];
Py_INCREF(dflt);
return dflt;
return Py_NewRef(dflt);
}
}
else {
@ -1162,8 +1158,7 @@ builtin_globals_impl(PyObject *module)
PyObject *d;
d = PyEval_GetGlobals();
Py_XINCREF(d);
return d;
return Py_XNewRef(d);
}
@ -1390,12 +1385,10 @@ map_reduce(mapobject *lz, PyObject *Py_UNUSED(ignored))
Py_ssize_t i;
if (args == NULL)
return NULL;
Py_INCREF(lz->func);
PyTuple_SET_ITEM(args, 0, lz->func);
PyTuple_SET_ITEM(args, 0, Py_NewRef(lz->func));
for (i = 0; i<numargs; i++){
PyObject *it = PyTuple_GET_ITEM(lz->iters, i);
Py_INCREF(it);
PyTuple_SET_ITEM(args, i+1, it);
PyTuple_SET_ITEM(args, i+1, Py_NewRef(it));
}
return Py_BuildValue("ON", Py_TYPE(lz), args);
@ -1486,8 +1479,7 @@ builtin_next(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
return NULL;
PyErr_Clear();
}
Py_INCREF(def);
return def;
return Py_NewRef(def);
} else if (PyErr_Occurred()) {
return NULL;
} else {
@ -1723,8 +1715,7 @@ builtin_locals_impl(PyObject *module)
PyObject *d;
d = PyEval_GetLocals();
Py_XINCREF(d);
return d;
return Py_XNewRef(d);
}
@ -1785,8 +1776,7 @@ min_max(PyObject *args, PyObject *kwds, int op)
}
/* no key function; the value is the item */
else {
val = item;
Py_INCREF(val);
val = Py_NewRef(item);
}
/* maximum value and item are unset; set them */
@ -1816,8 +1806,7 @@ min_max(PyObject *args, PyObject *kwds, int op)
if (maxval == NULL) {
assert(maxitem == NULL);
if (defaultval != NULL) {
Py_INCREF(defaultval);
maxitem = defaultval;
maxitem = Py_NewRef(defaultval);
} else {
PyErr_Format(PyExc_ValueError,
"%s() arg is an empty sequence", name);
@ -2737,8 +2726,7 @@ zip_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
return NULL;
}
for (i=0 ; i < tuplesize ; i++) {
Py_INCREF(Py_None);
PyTuple_SET_ITEM(result, i, Py_None);
PyTuple_SET_ITEM(result, i, Py_NewRef(Py_None));
}
/* create zipobject structure */

75
Python/compile.c
View file

@ -530,8 +530,7 @@ _Py_Mangle(PyObject *privateobj, PyObject *ident)
if (privateobj == NULL || !PyUnicode_Check(privateobj) ||
PyUnicode_READ_CHAR(ident, 0) != '_' ||
PyUnicode_READ_CHAR(ident, 1) != '_') {
Py_INCREF(ident);
return ident;
return Py_NewRef(ident);
}
nlen = PyUnicode_GET_LENGTH(ident);
plen = PyUnicode_GET_LENGTH(privateobj);
@ -547,16 +546,14 @@ _Py_Mangle(PyObject *privateobj, PyObject *ident)
if ((PyUnicode_READ_CHAR(ident, nlen-1) == '_' &&
PyUnicode_READ_CHAR(ident, nlen-2) == '_') ||
PyUnicode_FindChar(ident, '.', 0, nlen, 1) != -1) {
Py_INCREF(ident);
return ident; /* Don't mangle __whatever__ */
return Py_NewRef(ident); /* Don't mangle __whatever__ */
}
/* Strip leading underscores from class name */
ipriv = 0;
while (PyUnicode_READ_CHAR(privateobj, ipriv) == '_')
ipriv++;
if (ipriv == plen) {
Py_INCREF(ident);
return ident; /* Don't mangle if class is just underscores */
return Py_NewRef(ident); /* Don't mangle if class is just underscores */
}
plen -= ipriv;
@ -616,8 +613,7 @@ _PyAST_Compile(mod_ty mod, PyObject *filename, PyCompilerFlags *flags,
int merged;
if (!compiler_init(&c))
return NULL;
Py_INCREF(filename);
c.c_filename = filename;
c.c_filename = Py_NewRef(filename);
c.c_arena = arena;
if (!_PyFuture_FromAST(mod, filename, &c.c_future)) {
goto finally;
@ -859,8 +855,7 @@ compiler_set_qualname(struct compiler *c)
return 0;
}
else {
Py_INCREF(parent->u_qualname);
base = parent->u_qualname;
base = Py_NewRef(parent->u_qualname);
}
}
}
@ -876,8 +871,7 @@ compiler_set_qualname(struct compiler *c)
return 0;
}
else {
Py_INCREF(u->u_name);
name = u->u_name;
name = Py_NewRef(u->u_name);
}
u->u_qualname = name;
@ -1381,8 +1375,7 @@ merge_consts_recursive(PyObject *const_cache, PyObject *o)
// None and Ellipsis are singleton, and key is the singleton.
// No need to merge object and key.
if (o == Py_None || o == Py_Ellipsis) {
Py_INCREF(o);
return o;
return Py_NewRef(o);
}
PyObject *key = _PyCode_ConstantKey(o);
@ -1421,8 +1414,7 @@ merge_consts_recursive(PyObject *const_cache, PyObject *o)
v = u;
}
if (v != item) {
Py_INCREF(v);
PyTuple_SET_ITEM(o, i, v);
PyTuple_SET_ITEM(o, i, Py_NewRef(v));
Py_DECREF(item);
}
@ -1708,8 +1700,7 @@ compiler_enter_scope(struct compiler *c, identifier name,
compiler_unit_free(u);
return 0;
}
Py_INCREF(name);
u->u_name = name;
u->u_name = Py_NewRef(name);
u->u_varnames = list2dict(u->u_ste->ste_varnames);
u->u_cellvars = dictbytype(u->u_ste->ste_symbols, CELL, 0, 0);
if (!u->u_varnames || !u->u_cellvars) {
@ -1760,8 +1751,7 @@ compiler_enter_scope(struct compiler *c, identifier name,
return 0;
}
Py_DECREF(capsule);
u->u_private = c->u->u_private;
Py_XINCREF(u->u_private);
u->u_private = Py_XNewRef(c->u->u_private);
}
c->u = u;
@ -2671,8 +2661,7 @@ compiler_function(struct compiler *c, stmt_ty s, int is_async)
}
}
co = assemble(c, 1);
qualname = c->u->u_qualname;
Py_INCREF(qualname);
qualname = Py_NewRef(c->u->u_qualname);
compiler_exit_scope(c);
if (co == NULL) {
Py_XDECREF(qualname);
@ -3053,8 +3042,7 @@ compiler_lambda(struct compiler *c, expr_ty e)
ADDOP_IN_SCOPE(c, loc, RETURN_VALUE);
co = assemble(c, 1);
}
qualname = c->u->u_qualname;
Py_INCREF(qualname);
qualname = Py_NewRef(c->u->u_qualname);
compiler_exit_scope(c);
if (co == NULL) {
Py_DECREF(qualname);
@ -3925,8 +3913,7 @@ compiler_from_import(struct compiler *c, stmt_ty s)
/* build up the names */
for (Py_ssize_t i = 0; i < n; i++) {
alias_ty alias = (alias_ty)asdl_seq_GET(s->v.ImportFrom.names, i);
Py_INCREF(alias->name);
PyTuple_SET_ITEM(names, i, alias->name);
PyTuple_SET_ITEM(names, i, Py_NewRef(alias->name));
}
if (location_is_after(LOC(s), c->c_future.ff_location) &&
@ -4348,8 +4335,7 @@ starunpack_helper(struct compiler *c, location loc,
PyObject *val;
for (Py_ssize_t i = 0; i < n; i++) {
val = ((expr_ty)asdl_seq_GET(elts, i))->v.Constant.value;
Py_INCREF(val);
PyTuple_SET_ITEM(folded, i, val);
PyTuple_SET_ITEM(folded, i, Py_NewRef(val));
}
if (tuple && !pushed) {
ADDOP_LOAD_CONST_NEW(c, loc, folded);
@ -4530,8 +4516,7 @@ compiler_subdict(struct compiler *c, expr_ty e, Py_ssize_t begin, Py_ssize_t end
}
for (i = begin; i < end; i++) {
key = ((expr_ty)asdl_seq_GET(e->v.Dict.keys, i))->v.Constant.value;
Py_INCREF(key);
PyTuple_SET_ITEM(keys, i - begin, key);
PyTuple_SET_ITEM(keys, i - begin, Py_NewRef(key));
}
ADDOP_LOAD_CONST_NEW(c, loc, keys);
ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n);
@ -5014,8 +4999,7 @@ compiler_subkwargs(struct compiler *c, location loc,
}
for (i = begin; i < end; i++) {
key = ((keyword_ty) asdl_seq_GET(keywords, i))->arg;
Py_INCREF(key);
PyTuple_SET_ITEM(keys, i - begin, key);
PyTuple_SET_ITEM(keys, i - begin, Py_NewRef(key));
}
ADDOP_LOAD_CONST_NEW(c, loc, keys);
ADDOP_I(c, loc, BUILD_CONST_KEY_MAP, n);
@ -5053,8 +5037,7 @@ compiler_call_simple_kw_helper(struct compiler *c, location loc,
}
for (int i = 0; i < nkwelts; i++) {
keyword_ty kw = asdl_seq_GET(keywords, i);
Py_INCREF(kw->arg);
PyTuple_SET_ITEM(names, i, kw->arg);
PyTuple_SET_ITEM(names, i, Py_NewRef(kw->arg));
}
Py_ssize_t arg = compiler_add_const(c, names);
if (arg < 0) {
@ -5490,8 +5473,7 @@ compiler_comprehension(struct compiler *c, expr_ty e, int type,
}
co = assemble(c, 1);
qualname = c->u->u_qualname;
Py_INCREF(qualname);
qualname = Py_NewRef(c->u->u_qualname);
compiler_exit_scope(c);
if (is_top_level_await && is_async_generator){
c->u->u_ste->ste_coroutine = 1;
@ -6170,8 +6152,7 @@ compiler_error(struct compiler *c, location loc,
}
PyObject *loc_obj = PyErr_ProgramTextObject(c->c_filename, loc.lineno);
if (loc_obj == NULL) {
Py_INCREF(Py_None);
loc_obj = Py_None;
loc_obj = Py_NewRef(Py_None);
}
PyObject *args = Py_BuildValue("O(OiiOii)", msg, c->c_filename,
loc.lineno, loc.col_offset + 1, loc_obj,
@ -6605,8 +6586,7 @@ compiler_pattern_class(struct compiler *c, location *ploc,
Py_ssize_t i;
for (i = 0; i < nattrs; i++) {
PyObject *name = asdl_seq_GET(kwd_attrs, i);
Py_INCREF(name);
PyTuple_SET_ITEM(attr_names, i, name);
PyTuple_SET_ITEM(attr_names, i, Py_NewRef(name));
}
ADDOP_LOAD_CONST_NEW(c, *ploc, attr_names);
ADDOP_I(c, *ploc, MATCH_CLASS, nargs);
@ -6815,8 +6795,7 @@ compiler_pattern_or(struct compiler *c, location *ploc,
// for the others (they can't bind a different set of names, and
// might need to be reordered):
assert(control == NULL);
control = pc->stores;
Py_INCREF(control);
control = Py_NewRef(pc->stores);
}
else if (nstores != PyList_GET_SIZE(control)) {
goto diff;
@ -8208,10 +8187,9 @@ dict_keys_inorder(PyObject *dict, Py_ssize_t offset)
return NULL;
while (PyDict_Next(dict, &pos, &k, &v)) {
i = PyLong_AS_LONG(v);
Py_INCREF(k);
assert((i - offset) < size);
assert((i - offset) >= 0);
PyTuple_SET_ITEM(tuple, i - offset, k);
PyTuple_SET_ITEM(tuple, i - offset, Py_NewRef(k));
}
return tuple;
}
@ -8233,10 +8211,9 @@ consts_dict_keys_inorder(PyObject *dict)
if (PyTuple_CheckExact(k)) {
k = PyTuple_GET_ITEM(k, 1);
}
Py_INCREF(k);
assert(i < size);
assert(i >= 0);
PyList_SET_ITEM(consts, i, k);
PyList_SET_ITEM(consts, i, Py_NewRef(k));
}
return consts;
}
@ -8936,8 +8913,7 @@ get_const_value(int opcode, int oparg, PyObject *co_consts)
"Internal error: failed to get value of a constant");
return NULL;
}
Py_INCREF(constant);
return constant;
return Py_NewRef(constant);
}
/* Replace LOAD_CONST c1, LOAD_CONST c2 ... LOAD_CONST cn, BUILD_TUPLE n
@ -9978,6 +9954,5 @@ PyObject *
PyCode_Optimize(PyObject *code, PyObject* Py_UNUSED(consts),
PyObject *Py_UNUSED(names), PyObject *Py_UNUSED(lnotab_obj))
{
Py_INCREF(code);
return code;
return Py_NewRef(code);
}

42
Python/context.c
View file

@ -124,8 +124,7 @@ _PyContext_Enter(PyThreadState *ts, PyObject *octx)
ctx->ctx_prev = (PyContext *)ts->context; /* borrow */
ctx->ctx_entered = 1;
Py_INCREF(ctx);
ts->context = (PyObject *)ctx;
ts->context = Py_NewRef(ctx);
ts->context_ver++;
return 0;
@ -400,8 +399,7 @@ context_new_from_vars(PyHamtObject *vars)
return NULL;
}
Py_INCREF(vars);
ctx->ctx_vars = vars;
ctx->ctx_vars = (PyHamtObject*)Py_NewRef(vars);
_PyObject_GC_TRACK(ctx);
return ctx;
@ -546,8 +544,7 @@ context_tp_subscript(PyContext *self, PyObject *key)
PyErr_SetObject(PyExc_KeyError, key);
return NULL;
}
Py_INCREF(val);
return val;
return Py_NewRef(val);
}
static int
@ -588,11 +585,9 @@ _contextvars_Context_get_impl(PyContext *self, PyObject *key,
return NULL;
}
if (found == 0) {
Py_INCREF(default_value);
return default_value;
return Py_NewRef(default_value);
}
Py_INCREF(val);
return val;
return Py_NewRef(val);
}
@ -831,11 +826,9 @@ contextvar_new(PyObject *name, PyObject *def)
return NULL;
}
Py_INCREF(name);
var->var_name = name;
var->var_name = Py_NewRef(name);
Py_XINCREF(def);
var->var_default = def;
var->var_default = Py_XNewRef(def);
var->var_cached = NULL;
var->var_cached_tsid = 0;
@ -1176,8 +1169,7 @@ token_tp_repr(PyContextToken *self)
static PyObject *
token_get_var(PyContextToken *self, void *Py_UNUSED(ignored))
{
Py_INCREF(self->tok_var);
return (PyObject *)self->tok_var;
return Py_NewRef(self->tok_var);;
}
static PyObject *
@ -1187,8 +1179,7 @@ token_get_old_value(PyContextToken *self, void *Py_UNUSED(ignored))
return get_token_missing();
}
Py_INCREF(self->tok_oldval);
return self->tok_oldval;
return Py_NewRef(self->tok_oldval);
}
static PyGetSetDef PyContextTokenType_getsetlist[] = {
@ -1228,14 +1219,11 @@ token_new(PyContext *ctx, PyContextVar *var, PyObject *val)
return NULL;
}
Py_INCREF(ctx);
tok->tok_ctx = ctx;
tok->tok_ctx = (PyContext*)Py_NewRef(ctx);
Py_INCREF(var);
tok->tok_var = var;
tok->tok_var = (PyContextVar*)Py_NewRef(var);
Py_XINCREF(val);
tok->tok_oldval = val;
tok->tok_oldval = Py_XNewRef(val);
tok->tok_used = 0;
@ -1276,8 +1264,7 @@ static PyObject *
get_token_missing(void)
{
if (_token_missing != NULL) {
Py_INCREF(_token_missing);
return _token_missing;
return Py_NewRef(_token_missing);
}
_token_missing = (PyObject *)PyObject_New(
@ -1286,8 +1273,7 @@ get_token_missing(void)
return NULL;
}
Py_INCREF(_token_missing);
return _token_missing;
return Py_NewRef(_token_missing);
}

141
Python/hamt.c
View file

@ -525,8 +525,7 @@ hamt_node_bitmap_new(Py_ssize_t size)
assert(size % 2 == 0);
if (size == 0 && _empty_bitmap_node != NULL) {
Py_INCREF(_empty_bitmap_node);
return (PyHamtNode *)_empty_bitmap_node;
return (PyHamtNode *)Py_NewRef(_empty_bitmap_node);
}
/* No freelist; allocate a new bitmap node */
@ -550,8 +549,7 @@ hamt_node_bitmap_new(Py_ssize_t size)
/* Since bitmap nodes are immutable, we can cache the instance
for size=0 and reuse it whenever we need an empty bitmap node.
*/
_empty_bitmap_node = node;
Py_INCREF(_empty_bitmap_node);
_empty_bitmap_node = (PyHamtNode_Bitmap*)Py_NewRef(node);
}
return (PyHamtNode *)node;
@ -577,8 +575,7 @@ hamt_node_bitmap_clone(PyHamtNode_Bitmap *node)
}
for (i = 0; i < Py_SIZE(node); i++) {
Py_XINCREF(node->b_array[i]);
clone->b_array[i] = node->b_array[i];
clone->b_array[i] = Py_XNewRef(node->b_array[i]);
}
clone->b_bitmap = node->b_bitmap;
@ -603,14 +600,12 @@ hamt_node_bitmap_clone_without(PyHamtNode_Bitmap *o, uint32_t bit)
uint32_t i;
for (i = 0; i < key_idx; i++) {
Py_XINCREF(o->b_array[i]);
new->b_array[i] = o->b_array[i];
new->b_array[i] = Py_XNewRef(o->b_array[i]);
}
assert(Py_SIZE(o) >= 0 && Py_SIZE(o) <= 32);
for (i = val_idx + 1; i < (uint32_t)Py_SIZE(o); i++) {
Py_XINCREF(o->b_array[i]);
new->b_array[i - 2] = o->b_array[i];
new->b_array[i - 2] = Py_XNewRef(o->b_array[i]);
}
new->b_bitmap = o->b_bitmap & ~bit;
@ -643,15 +638,11 @@ hamt_node_new_bitmap_or_collision(uint32_t shift,
return NULL;
}
Py_INCREF(key1);
n->c_array[0] = key1;
Py_INCREF(val1);
n->c_array[1] = val1;
n->c_array[0] = Py_NewRef(key1);
n->c_array[1] = Py_NewRef(val1);
Py_INCREF(key2);
n->c_array[2] = key2;
Py_INCREF(val2);
n->c_array[3] = val2;
n->c_array[2] = Py_NewRef(key2);
n->c_array[3] = Py_NewRef(val2);
return (PyHamtNode *)n;
}
@ -736,8 +727,7 @@ hamt_node_bitmap_assoc(PyHamtNode_Bitmap *self,
if (val_or_node == (PyObject *)sub_node) {
Py_DECREF(sub_node);
Py_INCREF(self);
return (PyHamtNode *)self;
return (PyHamtNode *)Py_NewRef(self);
}
PyHamtNode_Bitmap *ret = hamt_node_bitmap_clone(self);
@ -759,8 +749,7 @@ hamt_node_bitmap_assoc(PyHamtNode_Bitmap *self,
if (comp_err == 1) { /* key == key_or_null */
if (val == val_or_node) {
/* we already have the same key/val pair; return self. */
Py_INCREF(self);
return (PyHamtNode *)self;
return (PyHamtNode *)Py_NewRef(self);
}
/* We're setting a new value for the key we had before.
@ -769,8 +758,7 @@ hamt_node_bitmap_assoc(PyHamtNode_Bitmap *self,
if (ret == NULL) {
return NULL;
}
Py_INCREF(val);
Py_SETREF(ret->b_array[val_idx], val);
Py_SETREF(ret->b_array[val_idx], Py_NewRef(val));
return (PyHamtNode *)ret;
}
@ -923,22 +911,18 @@ hamt_node_bitmap_assoc(PyHamtNode_Bitmap *self,
/* Copy all keys/values that will be before the new key/value
we are adding. */
for (i = 0; i < key_idx; i++) {
Py_XINCREF(self->b_array[i]);
new_node->b_array[i] = self->b_array[i];
new_node->b_array[i] = Py_XNewRef(self->b_array[i]);
}
/* Set the new key/value to the new Bitmap node. */
Py_INCREF(key);
new_node->b_array[key_idx] = key;
Py_INCREF(val);
new_node->b_array[val_idx] = val;
new_node->b_array[key_idx] = Py_NewRef(key);
new_node->b_array[val_idx] = Py_NewRef(val);
/* Copy all keys/values that will be after the new key/value
we are adding. */
assert(Py_SIZE(self) >= 0 && Py_SIZE(self) <= 32);
for (i = key_idx; i < (uint32_t)Py_SIZE(self); i++) {
Py_XINCREF(self->b_array[i]);
new_node->b_array[i + 2] = self->b_array[i];
new_node->b_array[i + 2] = Py_XNewRef(self->b_array[i]);
}
new_node->b_bitmap = self->b_bitmap | bit;
@ -1019,10 +1003,8 @@ hamt_node_bitmap_without(PyHamtNode_Bitmap *self,
PyObject *key = sub_tree->b_array[0];
PyObject *val = sub_tree->b_array[1];
Py_INCREF(key);
Py_XSETREF(clone->b_array[key_idx], key);
Py_INCREF(val);
Py_SETREF(clone->b_array[val_idx], val);
Py_XSETREF(clone->b_array[key_idx], Py_NewRef(key));
Py_SETREF(clone->b_array[val_idx], Py_NewRef(val));
Py_DECREF(sub_tree);
@ -1343,14 +1325,11 @@ hamt_node_collision_assoc(PyHamtNode_Collision *self,
}
for (i = 0; i < Py_SIZE(self); i++) {
Py_INCREF(self->c_array[i]);
new_node->c_array[i] = self->c_array[i];
new_node->c_array[i] = Py_NewRef(self->c_array[i]);
}
Py_INCREF(key);
new_node->c_array[i] = key;
Py_INCREF(val);
new_node->c_array[i + 1] = val;
new_node->c_array[i] = Py_NewRef(key);
new_node->c_array[i + 1] = Py_NewRef(val);
*added_leaf = 1;
return (PyHamtNode *)new_node;
@ -1364,8 +1343,7 @@ hamt_node_collision_assoc(PyHamtNode_Collision *self,
if (self->c_array[val_idx] == val) {
/* We're setting a key/value pair that's already set. */
Py_INCREF(self);
return (PyHamtNode *)self;
return (PyHamtNode *)Py_NewRef(self);
}
/* We need to replace old value for the key
@ -1378,14 +1356,12 @@ hamt_node_collision_assoc(PyHamtNode_Collision *self,
/* Copy all elements of the old node to the new one. */
for (i = 0; i < Py_SIZE(self); i++) {
Py_INCREF(self->c_array[i]);
new_node->c_array[i] = self->c_array[i];
new_node->c_array[i] = Py_NewRef(self->c_array[i]);
}
/* Replace the old value with the new value for the our key. */
Py_DECREF(new_node->c_array[val_idx]);
Py_INCREF(val);
new_node->c_array[val_idx] = val;
new_node->c_array[val_idx] = Py_NewRef(val);
return (PyHamtNode *)new_node;
@ -1410,8 +1386,7 @@ hamt_node_collision_assoc(PyHamtNode_Collision *self,
return NULL;
}
new_node->b_bitmap = hamt_bitpos(self->c_hash, shift);
Py_INCREF(self);
new_node->b_array[1] = (PyObject*) self;
new_node->b_array[1] = Py_NewRef(self);
assoc_res = hamt_node_bitmap_assoc(
new_node, shift, hash, key, val, added_leaf);
@ -1473,17 +1448,13 @@ hamt_node_collision_without(PyHamtNode_Collision *self,
}
if (key_idx == 0) {
Py_INCREF(self->c_array[2]);
node->b_array[0] = self->c_array[2];
Py_INCREF(self->c_array[3]);
node->b_array[1] = self->c_array[3];
node->b_array[0] = Py_NewRef(self->c_array[2]);
node->b_array[1] = Py_NewRef(self->c_array[3]);
}
else {
assert(key_idx == 2);
Py_INCREF(self->c_array[0]);
node->b_array[0] = self->c_array[0];
Py_INCREF(self->c_array[1]);
node->b_array[1] = self->c_array[1];
node->b_array[0] = Py_NewRef(self->c_array[0]);
node->b_array[1] = Py_NewRef(self->c_array[1]);
}
node->b_bitmap = hamt_bitpos(hash, shift);
@ -1504,12 +1475,10 @@ hamt_node_collision_without(PyHamtNode_Collision *self,
/* Copy all other keys from `self` to `new` */
Py_ssize_t i;
for (i = 0; i < key_idx; i++) {
Py_INCREF(self->c_array[i]);
new->c_array[i] = self->c_array[i];
new->c_array[i] = Py_NewRef(self->c_array[i]);
}
for (i = key_idx + 2; i < Py_SIZE(self); i++) {
Py_INCREF(self->c_array[i]);
new->c_array[i - 2] = self->c_array[i];
new->c_array[i - 2] = Py_NewRef(self->c_array[i]);
}
*new_node = (PyHamtNode*)new;
@ -1661,8 +1630,7 @@ hamt_node_array_clone(PyHamtNode_Array *node)
/* Copy all elements from the current Array node to the new one. */
for (i = 0; i < HAMT_ARRAY_NODE_SIZE; i++) {
Py_XINCREF(node->a_array[i]);
clone->a_array[i] = node->a_array[i];
clone->a_array[i] = (PyHamtNode*)Py_XNewRef(node->a_array[i]);
}
VALIDATE_ARRAY_NODE(clone)
@ -1719,8 +1687,7 @@ hamt_node_array_assoc(PyHamtNode_Array *self,
/* Copy all elements from the current Array node to the
new one. */
for (i = 0; i < HAMT_ARRAY_NODE_SIZE; i++) {
Py_XINCREF(self->a_array[i]);
new_node->a_array[i] = self->a_array[i];
new_node->a_array[i] = (PyHamtNode*)Py_XNewRef(self->a_array[i]);
}
assert(new_node->a_array[idx] == NULL);
@ -1868,15 +1835,12 @@ hamt_node_array_without(PyHamtNode_Array *self,
PyObject *key = child->b_array[0];
PyObject *val = child->b_array[1];
Py_INCREF(key);
new->b_array[new_i] = key;
Py_INCREF(val);
new->b_array[new_i + 1] = val;
new->b_array[new_i] = Py_NewRef(key);
new->b_array[new_i + 1] = Py_NewRef(val);
}
else {
new->b_array[new_i] = NULL;
Py_INCREF(node);
new->b_array[new_i + 1] = (PyObject*)node;
new->b_array[new_i + 1] = Py_NewRef(node);
}
}
else {
@ -1894,8 +1858,7 @@ hamt_node_array_without(PyHamtNode_Array *self,
/* Just copy the node into our new Bitmap */
new->b_array[new_i] = NULL;
Py_INCREF(node);
new->b_array[new_i + 1] = (PyObject*)node;
new->b_array[new_i + 1] = Py_NewRef(node);
}
new_i += 2;
@ -2311,8 +2274,7 @@ _PyHamt_Assoc(PyHamtObject *o, PyObject *key, PyObject *val)
if (new_root == o->h_root) {
Py_DECREF(new_root);
Py_INCREF(o);
return o;
return (PyHamtObject*)Py_NewRef(o);
}
new_o = hamt_alloc();
@ -2348,8 +2310,7 @@ _PyHamt_Without(PyHamtObject *o, PyObject *key)
case W_EMPTY:
return _PyHamt_New();
case W_NOT_FOUND:
Py_INCREF(o);
return o;
return (PyHamtObject*)Py_NewRef(o);
case W_NEWNODE: {
assert(new_root != NULL);
@ -2476,8 +2437,7 @@ _PyHamt_New(void)
if (_empty_hamt != NULL) {
/* HAMT is an immutable object so we can easily cache an
empty instance. */
Py_INCREF(_empty_hamt);
return _empty_hamt;
return (PyHamtObject*)Py_NewRef(_empty_hamt);
}
PyHamtObject *o = hamt_alloc();
@ -2494,8 +2454,7 @@ _PyHamt_New(void)
o->h_count = 0;
if (_empty_hamt == NULL) {
Py_INCREF(o);
_empty_hamt = o;
_empty_hamt = (PyHamtObject*)Py_NewRef(o);
}
return o;
@ -2591,8 +2550,7 @@ hamt_baseiter_new(PyTypeObject *type, binaryfunc yield, PyHamtObject *o)
return NULL;
}
Py_INCREF(o);
it->hi_obj = o;
it->hi_obj = (PyHamtObject*)Py_NewRef(o);
it->hi_yield = yield;
hamt_iterator_init(&it->hi_iter, o->h_root);
@ -2648,8 +2606,7 @@ PyTypeObject _PyHamtKeys_Type = {
static PyObject *
hamt_iter_yield_keys(PyObject *key, PyObject *val)
{
Py_INCREF(key);
return key;
return Py_NewRef(key);
}
PyObject *
@ -2672,8 +2629,7 @@ PyTypeObject _PyHamtValues_Type = {
static PyObject *
hamt_iter_yield_values(PyObject *key, PyObject *val)
{
Py_INCREF(val);
return val;
return Py_NewRef(val);
}
PyObject *
@ -2766,8 +2722,7 @@ hamt_tp_subscript(PyHamtObject *self, PyObject *key)
case F_ERROR:
return NULL;
case F_FOUND:
Py_INCREF(val);
return val;
return Py_NewRef(val);
case F_NOT_FOUND:
PyErr_SetObject(PyExc_KeyError, key);
return NULL;
@ -2817,14 +2772,12 @@ hamt_py_get(PyHamtObject *self, PyObject *args)
case F_ERROR:
return NULL;
case F_FOUND:
Py_INCREF(val);
return val;
return Py_NewRef(val);
case F_NOT_FOUND:
if (def == NULL) {
Py_RETURN_NONE;
}
Py_INCREF(def);
return def;
return Py_NewRef(def);
default:
Py_UNREACHABLE();
}

24
Python/import.c
View file

@ -810,8 +810,7 @@ update_code_filenames(PyCodeObject *co, PyObject *oldname, PyObject *newname)
if (PyUnicode_Compare(co->co_filename, oldname))
return;
Py_INCREF(newname);
Py_XSETREF(co->co_filename, newname);
Py_XSETREF(co->co_filename, Py_NewRef(newname));
constants = co->co_consts;
n = PyTuple_GET_SIZE(constants);
@ -905,8 +904,7 @@ get_path_importer(PyThreadState *tstate, PyObject *path_importer_cache,
importer = PyDict_GetItemWithError(path_importer_cache, p);
if (importer != NULL || _PyErr_Occurred(tstate)) {
Py_XINCREF(importer);
return importer;
return Py_XNewRef(importer);
}
/* set path_importer_cache[p] to None to avoid recursion */
@ -1403,8 +1401,7 @@ PyImport_ImportFrozenModuleObject(PyObject *name)
}
}
else {
Py_INCREF(Py_None);
origname = Py_None;
origname = Py_NewRef(Py_None);
}
err = PyDict_SetItemString(d, "__origname__", origname);
Py_DECREF(origname);
@ -1516,8 +1513,7 @@ remove_importlib_frames(PyThreadState *tstate)
if (in_importlib &&
(always_trim ||
_PyUnicode_EqualToASCIIString(code->co_name, remove_frames))) {
Py_XINCREF(next);
Py_XSETREF(*outer_link, next);
Py_XSETREF(*outer_link, Py_XNewRef(next));
prev_link = outer_link;
}
else {
@ -1813,8 +1809,7 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
_PyErr_SetString(tstate, PyExc_ValueError, "Empty module name");
goto error;
}
abs_name = name;
Py_INCREF(abs_name);
abs_name = Py_NewRef(name);
}
mod = import_get_module(tstate, abs_name);
@ -1853,8 +1848,7 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
if (dot == -1) {
/* No dot in module name, simple exit */
final_mod = mod;
Py_INCREF(mod);
final_mod = Py_NewRef(mod);
goto error;
}
@ -1889,8 +1883,7 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
}
}
else {
final_mod = mod;
Py_INCREF(mod);
final_mod = Py_NewRef(mod);
}
}
else {
@ -1905,8 +1898,7 @@ PyImport_ImportModuleLevelObject(PyObject *name, PyObject *globals,
mod, fromlist, interp->import_func, NULL);
}
else {
final_mod = mod;
Py_INCREF(mod);
final_mod = Py_NewRef(mod);
}
}

9
Python/structmember.c
View file

@ -49,8 +49,7 @@ PyMember_GetOne(const char *obj_addr, PyMemberDef *l)
break;
case T_STRING:
if (*(char**)addr == NULL) {
Py_INCREF(Py_None);
v = Py_None;
v = Py_NewRef(Py_None);
}
else
v = PyUnicode_FromString(*(char**)addr);
@ -85,8 +84,7 @@ PyMember_GetOne(const char *obj_addr, PyMemberDef *l)
v = PyLong_FromUnsignedLongLong(*(unsigned long long *)addr);
break;
case T_NONE:
v = Py_None;
Py_INCREF(v);
v = Py_NewRef(Py_None);
break;
default:
PyErr_SetString(PyExc_SystemError, "bad memberdescr type");
@ -247,9 +245,8 @@ PyMember_SetOne(char *addr, PyMemberDef *l, PyObject *v)
break;
case T_OBJECT:
case T_OBJECT_EX:
Py_XINCREF(v);
oldv = *(PyObject **)addr;
*(PyObject **)addr = v;
*(PyObject **)addr = Py_XNewRef(v);
Py_XDECREF(oldv);
break;
case T_CHAR: {

31
Python/sysmodule.c
View file

@ -838,8 +838,7 @@ sys_getdefaultencoding_impl(PyObject *module)
{
_Py_DECLARE_STR(utf_8, "utf-8");
PyObject *ret = &_Py_STR(utf_8);
Py_INCREF(ret);
return ret;
return Py_NewRef(ret);
}
/*[clinic input]
@ -1068,8 +1067,7 @@ sys_gettrace_impl(PyObject *module)
if (temp == NULL)
temp = Py_None;
Py_INCREF(temp);
return temp;
return Py_NewRef(temp);
}
static PyObject *
@ -1142,8 +1140,7 @@ sys_getprofile_impl(PyObject *module)
if (temp == NULL)
temp = Py_None;
Py_INCREF(temp);
return temp;
return Py_NewRef(temp);
}
@ -1368,11 +1365,8 @@ sys_get_asyncgen_hooks_impl(PyObject *module)
finalizer = Py_None;
}
Py_INCREF(firstiter);
PyStructSequence_SET_ITEM(res, 0, firstiter);
Py_INCREF(finalizer);
PyStructSequence_SET_ITEM(res, 1, finalizer);
PyStructSequence_SET_ITEM(res, 0, Py_NewRef(firstiter));
PyStructSequence_SET_ITEM(res, 1, Py_NewRef(finalizer));
return res;
}
@ -1805,8 +1799,7 @@ sys_getsizeof(PyObject *self, PyObject *args, PyObject *kwds)
/* Has a default value been given */
if (dflt != NULL && _PyErr_ExceptionMatches(tstate, PyExc_TypeError)) {
_PyErr_Clear(tstate);
Py_INCREF(dflt);
return dflt;
return Py_NewRef(dflt);
}
else
return NULL;
@ -2572,8 +2565,7 @@ _PySys_AddXOptionWithError(const wchar_t *s)
const wchar_t *name_end = wcschr(s, L'=');
if (!name_end) {
name = PyUnicode_FromWideChar(s, -1);
value = Py_True;
Py_INCREF(value);
value = Py_NewRef(Py_True);
}
else {
name = PyUnicode_FromWideChar(s, name_end - s);
@ -3028,8 +3020,7 @@ make_emscripten_info(void)
}
PyStructSequence_SET_ITEM(emscripten_info, pos++, oua);
} else {
Py_INCREF(Py_None);
PyStructSequence_SET_ITEM(emscripten_info, pos++, Py_None);
PyStructSequence_SET_ITEM(emscripten_info, pos++, Py_NewRef(Py_None));
}
#define SetBoolItem(flag) \
@ -3226,8 +3217,7 @@ sys_add_xoption(PyObject *opts, const wchar_t *s)
const wchar_t *name_end = wcschr(s, L'=');
if (!name_end) {
name = PyUnicode_FromWideChar(s, -1);
value = Py_True;
Py_INCREF(value);
value = Py_NewRef(Py_True);
}
else {
name = PyUnicode_FromWideChar(s, name_end - s);
@ -3404,8 +3394,7 @@ _PySys_Create(PyThreadState *tstate, PyObject **sysmod_p)
if (sysdict == NULL) {
goto error;
}
Py_INCREF(sysdict);
interp->sysdict = sysdict;
interp->sysdict = Py_NewRef(sysdict);
if (PyDict_SetItemString(sysdict, "modules", interp->modules) < 0) {
goto error;

15
Python/traceback.c
View file

@ -52,10 +52,8 @@ tb_create_raw(PyTracebackObject *next, PyFrameObject *frame, int lasti,
}
tb = PyObject_GC_New(PyTracebackObject, &PyTraceBack_Type);
if (tb != NULL) {
Py_XINCREF(next);
tb->tb_next = next;
Py_XINCREF(frame);
tb->tb_frame = frame;
tb->tb_next = (PyTracebackObject*)Py_XNewRef(next);
tb->tb_frame = (PyFrameObject*)Py_XNewRef(frame);
tb->tb_lasti = lasti;
tb->tb_lineno = lineno;
PyObject_GC_Track(tb);
@ -106,8 +104,7 @@ tb_next_get(PyTracebackObject *self, void *Py_UNUSED(_))
if (!ret) {
ret = Py_None;
}
Py_INCREF(ret);
return ret;
return Py_NewRef(ret);
}
static int
@ -140,8 +137,7 @@ tb_next_set(PyTracebackObject *self, PyObject *new_next, void *Py_UNUSED(_))
}
PyObject *old_next = (PyObject*)self->tb_next;
Py_XINCREF(new_next);
self->tb_next = (PyTracebackObject *)new_next;
self->tb_next = (PyTracebackObject *)Py_XNewRef(new_next);
Py_XDECREF(old_next);
return 0;
@ -522,8 +518,7 @@ display_source_line_with_margin(PyObject *f, PyObject *filename, int lineno, int
}
if (line) {
Py_INCREF(lineobj);
*line = lineobj;
*line = Py_NewRef(lineobj);
}
/* remove the indentation of the line */