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

gh-99300: Use Py_NewRef() in Objects/ directory (#99351) 

Replace Py_INCREF() and Py_XINCREF() with Py_NewRef() and
Py_XNewRef() in C files of the Objects/ directory.
This commit is contained in:
Victor Stinner 2022-11-10 23:40:31 +01:00 committed by GitHub
parent 584e55bd34
commit 1960eb005e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 100 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
Objects/longobject.c
View File

@ -62,8 +62,7 @@ get_small_int(sdigit ival)
{
assert(IS_SMALL_INT(ival));
PyObject *v = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + ival];
Py_INCREF(v);
return v;
return Py_NewRef(v);
}
static PyLongObject *
@ -1785,8 +1784,7 @@ pylong_int_to_decimal_string(PyObject *aa,
goto success;
}
else {
*p_output = (PyObject *)s;
Py_INCREF(s);
*p_output = Py_NewRef(s);
goto success;
}
@ -2911,8 +2909,7 @@ long_divrem(PyLongObject *a, PyLongObject *b,
return -1;
}
PyObject *zero = _PyLong_GetZero();
Py_INCREF(zero);
*pdiv = (PyLongObject*)zero;
*pdiv = (PyLongObject*)Py_NewRef(zero);
return 0;
}
if (size_b == 1) {
@ -3747,10 +3744,8 @@ k_mul(PyLongObject *a, PyLongObject *b)
assert(Py_SIZE(ah) > 0); /* the split isn't degenerate */
if (a == b) {
bh = ah;
bl = al;
Py_INCREF(bh);
Py_INCREF(bl);
bh = (PyLongObject*)Py_NewRef(ah);
bl = (PyLongObject*)Py_NewRef(al);
}
else if (kmul_split(b, shift, &bh, &bl) < 0) goto fail;
@ -3822,8 +3817,7 @@ k_mul(PyLongObject *a, PyLongObject *b)
ah = al = NULL;
if (a == b) {
t2 = t1;
Py_INCREF(t2);
t2 = (PyLongObject*)Py_NewRef(t1);
}
else if ((t2 = x_add(bh, bl)) == NULL) {
Py_DECREF(t1);
@ -4067,12 +4061,10 @@ pylong_int_divmod(PyLongObject *v, PyLongObject *w,
return -1;
}
if (pdiv != NULL) {
Py_INCREF(q);
*pdiv = (PyLongObject *)q;
*pdiv = (PyLongObject *)Py_NewRef(q);
}
if (pmod != NULL) {
Py_INCREF(r);
*pmod = (PyLongObject *)r;
*pmod = (PyLongObject *)Py_NewRef(r);
}
Py_DECREF(result);
return 0;
@ -4638,11 +4630,10 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
/* a, b, c = v, w, x */
CHECK_BINOP(v, w);
a = (PyLongObject*)v; Py_INCREF(a);
b = (PyLongObject*)w; Py_INCREF(b);
a = (PyLongObject*)Py_NewRef(v);
b = (PyLongObject*)Py_NewRef(w);
if (PyLong_Check(x)) {
c = (PyLongObject *)x;
Py_INCREF(x);
c = (PyLongObject *)Py_NewRef(x);
}
else if (x == Py_None)
c = NULL;
@ -4824,8 +4815,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
/* Left-to-right k-ary sliding window exponentiation
* (Handbook of Applied Cryptography (HAC) Algorithm 14.85)
*/
Py_INCREF(a);
table[0] = a;
table[0] = (PyLongObject*)Py_NewRef(a);
num_table_entries = 1;
MULT(a, a, a2);
/* table[i] == a**(2*i + 1) % c */
@ -5362,11 +5352,12 @@ long_or(PyObject *a, PyObject *b)
static PyObject *
long_long(PyObject *v)
{
if (PyLong_CheckExact(v))
Py_INCREF(v);
else
v = _PyLong_Copy((PyLongObject *)v);
return v;
if (PyLong_CheckExact(v)) {
return Py_NewRef(v);
}
else {
return _PyLong_Copy((PyLongObject *)v);
}
}
PyObject *
@ -5473,8 +5464,7 @@ _PyLong_GCD(PyObject *aarg, PyObject *barg)
Py_SET_SIZE(c, size_a);
}
else if (Py_REFCNT(a) == 1) {
Py_INCREF(a);
c = a;
c = (PyLongObject*)Py_NewRef(a);
}
else {
alloc_a = size_a;
@ -5487,8 +5477,7 @@ _PyLong_GCD(PyObject *aarg, PyObject *barg)
Py_SET_SIZE(d, size_a);
}
else if (Py_REFCNT(b) == 1 && size_a <= alloc_b) {
Py_INCREF(b);
d = b;
d = (PyLongObject*)Py_NewRef(b);
Py_SET_SIZE(d, size_a);
}
else {

51
Objects/rangeobject.c
View File

@ -105,10 +105,8 @@ range_from_array(PyTypeObject *type, PyObject *const *args, Py_ssize_t num_args)
if (!stop) {
return NULL;
}
start = _PyLong_GetZero();
Py_INCREF(start);
step = _PyLong_GetOne();
Py_INCREF(step);
start = Py_NewRef(_PyLong_GetZero());
step = Py_NewRef(_PyLong_GetOne());
break;
case 0:
PyErr_SetString(PyExc_TypeError,
@ -216,8 +214,7 @@ compute_range_length(PyObject *start, PyObject *stop, PyObject *step)
if (cmp_result < 0)
return NULL;
result = zero;
Py_INCREF(result);
return result;
return Py_NewRef(result);
}
if ((tmp1 = PyNumber_Subtract(hi, lo)) == NULL)
@ -297,8 +294,7 @@ compute_range_item(rangeobject *r, PyObject *arg)
return NULL;
}
} else {
i = arg;
Py_INCREF(i);
i = Py_NewRef(arg);
}
/* PyLong equivalent to:
@ -522,30 +518,24 @@ range_hash(rangeobject *r)
t = PyTuple_New(3);
if (!t)
return -1;
Py_INCREF(r->length);
PyTuple_SET_ITEM(t, 0, r->length);
PyTuple_SET_ITEM(t, 0, Py_NewRef(r->length));
cmp_result = PyObject_Not(r->length);
if (cmp_result == -1)
goto end;
if (cmp_result == 1) {
Py_INCREF(Py_None);
Py_INCREF(Py_None);
PyTuple_SET_ITEM(t, 1, Py_None);
PyTuple_SET_ITEM(t, 2, Py_None);
PyTuple_SET_ITEM(t, 1, Py_NewRef(Py_None));
PyTuple_SET_ITEM(t, 2, Py_NewRef(Py_None));
}
else {
Py_INCREF(r->start);
PyTuple_SET_ITEM(t, 1, r->start);
PyTuple_SET_ITEM(t, 1, Py_NewRef(r->start));
cmp_result = PyObject_RichCompareBool(r->length, _PyLong_GetOne(), Py_EQ);
if (cmp_result == -1)
goto end;
if (cmp_result == 1) {
Py_INCREF(Py_None);
PyTuple_SET_ITEM(t, 2, Py_None);
PyTuple_SET_ITEM(t, 2, Py_NewRef(Py_None));
}
else {
Py_INCREF(r->step);
PyTuple_SET_ITEM(t, 2, r->step);
PyTuple_SET_ITEM(t, 2, Py_NewRef(r->step));
}
}
result = PyObject_Hash(t);
@ -982,8 +972,7 @@ longrangeiter_setstate(longrangeiterobject *r, PyObject *state)
if (cmp > 0)
state = r->len;
}
Py_INCREF(state);
Py_XSETREF(r->index, state);
Py_XSETREF(r->index, Py_NewRef(state));
Py_RETURN_NONE;
}
@ -1118,14 +1107,10 @@ range_iter(PyObject *seq)
if (it == NULL)
return NULL;
it->start = r->start;
it->step = r->step;
it->len = r->length;
it->index = _PyLong_GetZero();
Py_INCREF(it->start);
Py_INCREF(it->step);
Py_INCREF(it->len);
Py_INCREF(it->index);
it->start = Py_NewRef(r->start);
it->step = Py_NewRef(r->step);
it->len = Py_NewRef(r->length);
it->index = Py_NewRef(_PyLong_GetZero());
return (PyObject *)it;
}
@ -1206,8 +1191,7 @@ long_range:
it->index = it->start = it->step = NULL;
/* start + (len - 1) * step */
it->len = range->length;
Py_INCREF(it->len);
it->len = Py_NewRef(range->length);
diff = PyNumber_Subtract(it->len, _PyLong_GetOne());
if (!diff)
@ -1228,8 +1212,7 @@ long_range:
if (!it->step)
goto create_failure;
it->index = _PyLong_GetZero();
Py_INCREF(it->index);
it->index = Py_NewRef(_PyLong_GetZero());
return (PyObject *)it;
create_failure:

45
Objects/tupleobject.c
View File

@ -61,8 +61,7 @@ tuple_alloc(Py_ssize_t size)
static inline PyObject *
tuple_get_empty(void)
{
Py_INCREF(&_Py_SINGLETON(tuple_empty));
return (PyObject *)&_Py_SINGLETON(tuple_empty);
return Py_NewRef(&_Py_SINGLETON(tuple_empty));
}
PyObject *
@ -171,8 +170,7 @@ PyTuple_Pack(Py_ssize_t n, ...)
items = result->ob_item;
for (i = 0; i < n; i++) {
o = va_arg(vargs, PyObject *);
Py_INCREF(o);
items[i] = o;
items[i] = Py_NewRef(o);
}
va_end(vargs);
_PyObject_GC_TRACK(result);
@ -367,8 +365,7 @@ tupleitem(PyTupleObject *a, Py_ssize_t i)
PyErr_SetString(PyExc_IndexError, "tuple index out of range");
return NULL;
}
Py_INCREF(a->ob_item[i]);
return a->ob_item[i];
return Py_NewRef(a->ob_item[i]);
}
PyObject *
@ -385,8 +382,7 @@ _PyTuple_FromArray(PyObject *const *src, Py_ssize_t n)
PyObject **dst = tuple->ob_item;
for (Py_ssize_t i = 0; i < n; i++) {
PyObject *item = src[i];
Py_INCREF(item);
dst[i] = item;
dst[i] = Py_NewRef(item);
}
_PyObject_GC_TRACK(tuple);
return (PyObject *)tuple;
@ -425,8 +421,7 @@ tupleslice(PyTupleObject *a, Py_ssize_t ilow,
if (ihigh < ilow)
ihigh = ilow;
if (ilow == 0 && ihigh == Py_SIZE(a) && PyTuple_CheckExact(a)) {
Py_INCREF(a);
return (PyObject *)a;
return Py_NewRef(a);
}
return _PyTuple_FromArray(a->ob_item + ilow, ihigh - ilow);
}
@ -449,8 +444,7 @@ tupleconcat(PyTupleObject *a, PyObject *bb)
PyObject **src, **dest;
PyTupleObject *np;
if (Py_SIZE(a) == 0 && PyTuple_CheckExact(bb)) {
Py_INCREF(bb);
return bb;
return Py_NewRef(bb);
}
if (!PyTuple_Check(bb)) {
PyErr_Format(PyExc_TypeError,
@ -461,8 +455,7 @@ tupleconcat(PyTupleObject *a, PyObject *bb)
PyTupleObject *b = (PyTupleObject *)bb;
if (Py_SIZE(b) == 0 && PyTuple_CheckExact(a)) {
Py_INCREF(a);
return (PyObject *)a;
return Py_NewRef(a);
}
assert((size_t)Py_SIZE(a) + (size_t)Py_SIZE(b) < PY_SSIZE_T_MAX);
size = Py_SIZE(a) + Py_SIZE(b);
@ -478,15 +471,13 @@ tupleconcat(PyTupleObject *a, PyObject *bb)
dest = np->ob_item;
for (i = 0; i < Py_SIZE(a); i++) {
PyObject *v = src[i];
Py_INCREF(v);
dest[i] = v;
dest[i] = Py_NewRef(v);
}
src = b->ob_item;
dest = np->ob_item + Py_SIZE(a);
for (i = 0; i < Py_SIZE(b); i++) {
PyObject *v = src[i];
Py_INCREF(v);
dest[i] = v;
dest[i] = Py_NewRef(v);
}
_PyObject_GC_TRACK(np);
return (PyObject *)np;
@ -500,8 +491,7 @@ tuplerepeat(PyTupleObject *a, Py_ssize_t n)
if (PyTuple_CheckExact(a)) {
/* Since tuples are immutable, we can return a shared
copy in this case */
Py_INCREF(a);
return (PyObject *)a;
return Py_NewRef(a);
}
}
if (input_size == 0 || n <= 0) {
@ -747,8 +737,7 @@ tuple_subtype_new(PyTypeObject *type, PyObject *iterable)
}
for (i = 0; i < n; i++) {
item = PyTuple_GET_ITEM(tmp, i);
Py_INCREF(item);
PyTuple_SET_ITEM(newobj, i, item);
PyTuple_SET_ITEM(newobj, i, Py_NewRef(item));
}
Py_DECREF(tmp);
@ -799,8 +788,7 @@ tuplesubscript(PyTupleObject* self, PyObject* item)
else if (start == 0 && step == 1 &&
slicelength == PyTuple_GET_SIZE(self) &&
PyTuple_CheckExact(self)) {
Py_INCREF(self);
return (PyObject *)self;
return Py_NewRef(self);
}
else {
PyTupleObject* result = tuple_alloc(slicelength);
@ -810,8 +798,7 @@ tuplesubscript(PyTupleObject* self, PyObject* item)
dest = result->ob_item;
for (cur = start, i = 0; i < slicelength;
cur += step, i++) {
it = src[cur];
Py_INCREF(it);
it = Py_NewRef(src[cur]);
dest[i] = it;
}
@ -1044,8 +1031,7 @@ tupleiter_next(tupleiterobject *it)
if (it->it_index < PyTuple_GET_SIZE(seq)) {
item = PyTuple_GET_ITEM(seq, it->it_index);
++it->it_index;
Py_INCREF(item);
return item;
return Py_NewRef(item);
}
it->it_seq = NULL;
@ -1146,8 +1132,7 @@ tuple_iter(PyObject *seq)
if (it == NULL)
return NULL;
it->it_index = 0;
Py_INCREF(seq);
it->it_seq = (PyTupleObject *)seq;
it->it_seq = (PyTupleObject *)Py_NewRef(seq);
_PyObject_GC_TRACK(it);
return (PyObject *)it;
}

102
Objects/typeobject.c
View File

@ -653,8 +653,7 @@ type_name(PyTypeObject *type, void *context)
if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
PyHeapTypeObject* et = (PyHeapTypeObject*)type;
Py_INCREF(et->ht_name);
return et->ht_name;
return Py_NewRef(et->ht_name);
}
else {
return PyUnicode_FromString(_PyType_Name(type));
@ -666,8 +665,7 @@ type_qualname(PyTypeObject *type, void *context)
{
if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
PyHeapTypeObject* et = (PyHeapTypeObject*)type;
Py_INCREF(et->ht_qualname);
return et->ht_qualname;
return Py_NewRef(et->ht_qualname);
}
else {
return PyUnicode_FromString(_PyType_Name(type));
@ -699,8 +697,7 @@ type_set_name(PyTypeObject *type, PyObject *value, void *context)
}
type->tp_name = tp_name;
Py_INCREF(value);
Py_SETREF(((PyHeapTypeObject*)type)->ht_name, value);
Py_SETREF(((PyHeapTypeObject*)type)->ht_name, Py_NewRef(value));
return 0;
}
@ -720,8 +717,7 @@ type_set_qualname(PyTypeObject *type, PyObject *value, void *context)
}
et = (PyHeapTypeObject*)type;
Py_INCREF(value);
Py_SETREF(et->ht_qualname, value);
Py_SETREF(et->ht_qualname, Py_NewRef(value));
return 0;
}
@ -749,8 +745,7 @@ type_module(PyTypeObject *type, void *context)
PyUnicode_InternInPlace(&mod);
}
else {
mod = &_Py_ID(builtins);
Py_INCREF(mod);
mod = Py_NewRef(&_Py_ID(builtins));
}
}
return mod;
@ -782,8 +777,7 @@ type_abstractmethods(PyTypeObject *type, void *context)
}
return NULL;
}
Py_INCREF(mod);
return mod;
return Py_NewRef(mod);
}
static int
@ -821,8 +815,7 @@ type_set_abstractmethods(PyTypeObject *type, PyObject *value, void *context)
static PyObject *
type_get_bases(PyTypeObject *type, void *context)
{
Py_INCREF(type->tp_bases);
return type->tp_bases;
return Py_NewRef(type->tp_bases);
}
static PyTypeObject *best_base(PyObject *);
@ -1016,8 +1009,7 @@ type_set_bases(PyTypeObject *type, PyObject *new_bases, void *context)
"", 2, 3, &cls, &new_mro, &old_mro);
/* Do not rollback if cls has a newer version of MRO. */
if (cls->tp_mro == new_mro) {
Py_XINCREF(old_mro);
cls->tp_mro = old_mro;
cls->tp_mro = Py_XNewRef(old_mro);
Py_DECREF(new_mro);
}
}
@ -1061,8 +1053,7 @@ type_get_doc(PyTypeObject *type, void *context)
result = PyDict_GetItemWithError(type->tp_dict, &_Py_ID(__doc__));
if (result == NULL) {
if (!PyErr_Occurred()) {
result = Py_None;
Py_INCREF(result);
result = Py_NewRef(Py_None);
}
}
else if (Py_TYPE(result)->tp_descr_get) {
@ -1264,8 +1255,7 @@ type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
if (nargs == 1 && (kwds == NULL || !PyDict_GET_SIZE(kwds))) {
obj = (PyObject *) Py_TYPE(PyTuple_GET_ITEM(args, 0));
Py_INCREF(obj);
return obj;
return Py_NewRef(obj);
}
/* SF bug 475327 -- if that didn't trigger, we need 3
@ -2144,12 +2134,11 @@ mro_implementation(PyTypeObject *type)
return NULL;
}
Py_INCREF(type);
PyTuple_SET_ITEM(result, 0, (PyObject *) type);
;
PyTuple_SET_ITEM(result, 0, Py_NewRef(type));
for (Py_ssize_t i = 0; i < k; i++) {
PyObject *cls = PyTuple_GET_ITEM(base->tp_mro, i);
Py_INCREF(cls);
PyTuple_SET_ITEM(result, i + 1, cls);
PyTuple_SET_ITEM(result, i + 1, Py_NewRef(cls));
}
return result;
}
@ -2185,8 +2174,7 @@ mro_implementation(PyTypeObject *type)
return NULL;
}
Py_INCREF(type);
PyList_SET_ITEM(result, 0, (PyObject *)type);
PyList_SET_ITEM(result, 0, Py_NewRef(type));
if (pmerge(result, to_merge, n + 1) < 0) {
Py_CLEAR(result);
}
@ -2331,8 +2319,7 @@ mro_internal(PyTypeObject *type, PyObject **p_old_mro)
/* Keep a reference to be able to do a reentrancy check below.
Don't let old_mro be GC'ed and its address be reused for
another object, like (suddenly!) a new tp_mro. */
old_mro = type->tp_mro;
Py_XINCREF(old_mro);
old_mro = Py_XNewRef(type->tp_mro);
new_mro = mro_invoke(type); /* might cause reentrance */
reent = (type->tp_mro != old_mro);
Py_XDECREF(old_mro);
@ -2550,8 +2537,7 @@ subtype_setdict(PyObject *obj, PyObject *value, void *context)
"not a '%.200s'", Py_TYPE(value)->tp_name);
return -1;
}
Py_XINCREF(value);
Py_XSETREF(*dictptr, value);
Py_XSETREF(*dictptr, Py_XNewRef(value));
return 0;
}
@ -2578,8 +2564,7 @@ subtype_getweakref(PyObject *obj, void *context)
result = Py_None;
else
result = *weaklistptr;
Py_INCREF(result);
return result;
return Py_NewRef(result);
}
/* Three variants on the subtype_getsets list. */
@ -5063,16 +5048,14 @@ object_richcompare(PyObject *self, PyObject *other, int op)
/* Return NotImplemented instead of False, so if two
objects are compared, both get a chance at the
comparison. See issue #1393. */
res = (self == other) ? Py_True : Py_NotImplemented;
Py_INCREF(res);
res = Py_NewRef((self == other) ? Py_True : Py_NotImplemented);
break;
case Py_NE:
/* By default, __ne__() delegates to __eq__() and inverts the result,
unless the latter returns NotImplemented. */
if (Py_TYPE(self)->tp_richcompare == NULL) {
res = Py_NotImplemented;
Py_INCREF(res);
res = Py_NewRef(Py_NotImplemented);
break;
}
res = (*Py_TYPE(self)->tp_richcompare)(self, other, Py_EQ);
@ -5083,17 +5066,15 @@ object_richcompare(PyObject *self, PyObject *other, int op)
res = NULL;
else {
if (ok)
res = Py_False;
res = Py_NewRef(Py_False);
else
res = Py_True;
Py_INCREF(res);
res = Py_NewRef(Py_True);
}
}
break;
default:
res = Py_NotImplemented;
Py_INCREF(res);
res = Py_NewRef(Py_NotImplemented);
break;
}
@ -5103,8 +5084,7 @@ object_richcompare(PyObject *self, PyObject *other, int op)
static PyObject *
object_get_class(PyObject *self, void *closure)
{
Py_INCREF(Py_TYPE(self));
return (PyObject *)(Py_TYPE(self));
return Py_NewRef(Py_TYPE(self));
}
static int
@ -5359,8 +5339,7 @@ _PyType_GetSlotNames(PyTypeObject *cls)
cls->tp_name, Py_TYPE(slotnames)->tp_name);
return NULL;
}
Py_INCREF(slotnames);
return slotnames;
return Py_NewRef(slotnames);
}
else {
if (PyErr_Occurred()) {
@ -5406,8 +5385,7 @@ object_getstate_default(PyObject *obj, int required)
}
if (_PyObject_IsInstanceDictEmpty(obj)) {
state = Py_None;
Py_INCREF(state);
state = Py_NewRef(Py_None);
}
else {
state = PyObject_GenericGetDict(obj, NULL);
@ -5665,8 +5643,7 @@ _PyObject_GetItemsIter(PyObject *obj, PyObject **listitems,
}
if (!PyList_Check(obj)) {
*listitems = Py_None;
Py_INCREF(*listitems);
*listitems = Py_NewRef(Py_None);
}
else {
*listitems = PyObject_GetIter(obj);
@ -5675,8 +5652,7 @@ _PyObject_GetItemsIter(PyObject *obj, PyObject **listitems,
}
if (!PyDict_Check(obj)) {
*dictitems = Py_None;
Py_INCREF(*dictitems);
*dictitems = Py_NewRef(Py_None);
}
else {
PyObject *items = PyObject_CallMethodNoArgs(obj, &_Py_ID(items));
@ -5741,12 +5717,10 @@ reduce_newobj(PyObject *obj)
return NULL;
}
cls = (PyObject *) Py_TYPE(obj);
Py_INCREF(cls);
PyTuple_SET_ITEM(newargs, 0, cls);
PyTuple_SET_ITEM(newargs, 0, Py_NewRef(cls));
for (i = 0; i < n; i++) {
PyObject *v = PyTuple_GET_ITEM(args, i);
Py_INCREF(v);
PyTuple_SET_ITEM(newargs, i+1, v);
PyTuple_SET_ITEM(newargs, i+1, Py_NewRef(v));
}
Py_XDECREF(args);
}
@ -8381,8 +8355,7 @@ slot_tp_descr_get(PyObject *self, PyObject *obj, PyObject *type)
/* Avoid further slowdowns */
if (tp->tp_descr_get == slot_tp_descr_get)
tp->tp_descr_get = NULL;
Py_INCREF(self);
return self;
return Py_NewRef(self);
}
if (obj == NULL)
obj = Py_None;
@ -9451,14 +9424,12 @@ supercheck(PyTypeObject *type, PyObject *obj)
/* Check for first bullet above (special case) */
if (PyType_Check(obj) && PyType_IsSubtype((PyTypeObject *)obj, type)) {
Py_INCREF(obj);
return (PyTypeObject *)obj;
return (PyTypeObject *)Py_NewRef(obj);
}
/* Normal case */
if (PyType_IsSubtype(Py_TYPE(obj), type)) {
Py_INCREF(Py_TYPE(obj));
return Py_TYPE(obj);
return (PyTypeObject*)Py_NewRef(Py_TYPE(obj));
}
else {
/* Try the slow way */
@ -9494,8 +9465,7 @@ super_descr_get(PyObject *self, PyObject *obj, PyObject *type)
if (obj == NULL || obj == Py_None || su->obj != NULL) {
/* Not binding to an object, or already bound */
Py_INCREF(self);
return self;
return Py_NewRef(self);
}
if (!Py_IS_TYPE(su, &PySuper_Type))
/* If su is an instance of a (strict) subclass of super,
@ -9511,10 +9481,8 @@ super_descr_get(PyObject *self, PyObject *obj, PyObject *type)
NULL, NULL);
if (newobj == NULL)
return NULL;
Py_INCREF(su->type);
Py_INCREF(obj);
newobj->type = su->type;
newobj->obj = obj;
newobj->type = (PyTypeObject*)Py_NewRef(su->type);
newobj->obj = Py_NewRef(obj);
newobj->obj_type = obj_type;
return (PyObject *)newobj;
}

39
Objects/unicodeobject.c
View File

@ -221,8 +221,7 @@ static inline PyObject* unicode_get_empty(void)
static inline PyObject* unicode_new_empty(void)
{
PyObject *empty = unicode_get_empty();
Py_INCREF(empty);
return empty;
return Py_NewRef(empty);
}
/* This dictionary holds all interned unicode strings. Note that references
@ -611,8 +610,7 @@ static PyObject*
unicode_result_unchanged(PyObject *unicode)
{
if (PyUnicode_CheckExact(unicode)) {
Py_INCREF(unicode);
return unicode;
return Py_NewRef(unicode);
}
else
/* Subtype -- return genuine unicode string with the same value. */
@ -2947,8 +2945,7 @@ PyUnicode_FromObject(PyObject *obj)
/* XXX Perhaps we should make this API an alias of
PyObject_Str() instead ?! */
if (PyUnicode_CheckExact(obj)) {
Py_INCREF(obj);
return obj;
return Py_NewRef(obj);
}
if (PyUnicode_Check(obj)) {
/* For a Unicode subtype that's not a Unicode object,
@ -8668,8 +8665,7 @@ _PyUnicode_TransformDecimalAndSpaceToASCII(PyObject *unicode)
}
if (PyUnicode_IS_ASCII(unicode)) {
/* If the string is already ASCII, just return the same string */
Py_INCREF(unicode);
return unicode;
return Py_NewRef(unicode);
}
Py_ssize_t len = PyUnicode_GET_LENGTH(unicode);
@ -9413,8 +9409,7 @@ _PyUnicode_JoinArray(PyObject *separator, PyObject *const *items, Py_ssize_t seq
if (seqlen == 1) {
if (PyUnicode_CheckExact(items[0])) {
res = items[0];
Py_INCREF(res);
return res;
return Py_NewRef(res);
}
seplen = 0;
maxchar = 0;
@ -9733,8 +9728,7 @@ split(PyObject *self,
out = PyList_New(1);
if (out == NULL)
return NULL;
Py_INCREF(self);
PyList_SET_ITEM(out, 0, self);
PyList_SET_ITEM(out, 0, Py_NewRef(self));
return out;
}
buf1 = PyUnicode_DATA(self);
@ -9826,8 +9820,7 @@ rsplit(PyObject *self,
out = PyList_New(1);
if (out == NULL)
return NULL;
Py_INCREF(self);
PyList_SET_ITEM(out, 0, self);
PyList_SET_ITEM(out, 0, Py_NewRef(self));
return out;
}
buf1 = PyUnicode_DATA(self);
@ -10746,8 +10739,7 @@ PyUnicode_Append(PyObject **p_left, PyObject *right)
PyObject *empty = unicode_get_empty(); // Borrowed reference
if (left == empty) {
Py_DECREF(left);
Py_INCREF(right);
*p_left = right;
*p_left = Py_NewRef(right);
return;
}
if (right == empty) {
@ -12977,8 +12969,7 @@ _PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer, PyObject *str)
if (writer->buffer == NULL && !writer->overallocate) {
assert(_PyUnicode_CheckConsistency(str, 1));
writer->readonly = 1;
Py_INCREF(str);
writer->buffer = str;
writer->buffer = Py_NewRef(str);
_PyUnicodeWriter_Update(writer);
writer->pos += len;
return 0;
@ -13641,8 +13632,7 @@ mainformatlong(PyObject *v,
assert(PyLong_Check(iobj));
}
else {
iobj = v;
Py_INCREF(iobj);
iobj = Py_NewRef(v);
}
if (PyLong_CheckExact(v)
@ -13965,8 +13955,7 @@ unicode_format_arg_format(struct unicode_formatter_t *ctx,
}
if (PyUnicode_CheckExact(v) && arg->ch == 's') {
*p_str = v;
Py_INCREF(*p_str);
*p_str = Py_NewRef(v);
}
else {
if (arg->ch == 's')
@ -14616,8 +14605,7 @@ PyUnicode_InternInPlace(PyObject **p)
}
if (t != s) {
Py_INCREF(t);
Py_SETREF(*p, t);
Py_SETREF(*p, Py_NewRef(t));
return;
}
@ -14887,8 +14875,7 @@ unicode_iter(PyObject *seq)
if (it == NULL)
return NULL;
it->it_index = 0;
Py_INCREF(seq);
it->it_seq = seq;
it->it_seq = Py_NewRef(seq);
_PyObject_GC_TRACK(it);
return (PyObject *)it;
}