[Python-checkins] cpython: Issue #28959: Added private macro PyDict_GET_SIZE for retrieving the size of
serhiy.storchaka
python-checkins at python.org
Fri Dec 16 09:19:14 EST 2016
https://hg.python.org/cpython/rev/dbf72357cb4a
changeset: 105670:dbf72357cb4a
user: Serhiy Storchaka <storchaka at gmail.com>
date: Fri Dec 16 16:18:57 2016 +0200
summary:
Issue #28959: Added private macro PyDict_GET_SIZE for retrieving the size of dict.
files:
Include/dictobject.h | 2 +
Include/odictobject.h | 2 +-
Modules/_ctypes/_ctypes.c | 2 +-
Modules/_datetimemodule.c | 2 +-
Modules/_decimal/_decimal.c | 2 +-
Modules/_elementtree.c | 2 +-
Modules/_functoolsmodule.c | 10 ++++----
Modules/_operator.c | 13 +----------
Modules/_pickle.c | 15 +++++--------
Modules/_sqlite/cache.c | 2 +-
Modules/_struct.c | 2 +-
Modules/itertoolsmodule.c | 6 ++--
Modules/selectmodule.c | 2 +-
Objects/abstract.c | 3 +-
Objects/descrobject.c | 2 +-
Objects/funcobject.c | 2 +-
Objects/methodobject.c | 9 ++++---
Objects/object.c | 4 +-
Objects/odictobject.c | 3 +-
Objects/setobject.c | 2 +-
Objects/sliceobject.c | 2 +-
Objects/typeobject.c | 16 +++++++-------
Python/ceval.c | 4 +-
Python/compile.c | 26 ++++++++----------------
Python/getargs.c | 6 ++--
25 files changed, 61 insertions(+), 80 deletions(-)
diff --git a/Include/dictobject.h b/Include/dictobject.h
--- a/Include/dictobject.h
+++ b/Include/dictobject.h
@@ -106,6 +106,8 @@
PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp);
PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key);
#ifndef Py_LIMITED_API
+/* Get the number of items of a dictionary. */
+#define PyDict_GET_SIZE(mp) (assert(PyDict_Check(mp)),((PyDictObject *)mp)->ma_used)
PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, Py_hash_t hash);
PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused);
PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp);
diff --git a/Include/odictobject.h b/Include/odictobject.h
--- a/Include/odictobject.h
+++ b/Include/odictobject.h
@@ -21,7 +21,7 @@
#define PyODict_Check(op) PyObject_TypeCheck(op, &PyODict_Type)
#define PyODict_CheckExact(op) (Py_TYPE(op) == &PyODict_Type)
-#define PyODict_SIZE(op) ((PyDictObject *)op)->ma_used
+#define PyODict_SIZE(op) PyDict_GET_SIZE((op))
#define PyODict_HasKey(od, key) (PyMapping_HasKey(PyObject *)od, key)
PyAPI_FUNC(PyObject *) PyODict_New(void);
diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
--- a/Modules/_ctypes/_ctypes.c
+++ b/Modules/_ctypes/_ctypes.c
@@ -3684,7 +3684,7 @@
must be the same as len(inargs) + len(kwds), otherwise we have
either too much or not enough arguments. */
- actual_args = PyTuple_GET_SIZE(inargs) + (kwds ? PyDict_Size(kwds) : 0);
+ actual_args = PyTuple_GET_SIZE(inargs) + (kwds ? PyDict_GET_SIZE(kwds) : 0);
if (actual_args != inargs_index) {
/* When we have default values or named parameters, this error
message is misleading. See unittests/test_paramflags.py
diff --git a/Modules/_datetimemodule.c b/Modules/_datetimemodule.c
--- a/Modules/_datetimemodule.c
+++ b/Modules/_datetimemodule.c
@@ -3169,7 +3169,7 @@
PyErr_Clear();
state = Py_None;
dictptr = _PyObject_GetDictPtr(self);
- if (dictptr && *dictptr && PyDict_Size(*dictptr)) {
+ if (dictptr && *dictptr && PyDict_GET_SIZE(*dictptr)) {
state = *dictptr;
}
Py_INCREF(state);
diff --git a/Modules/_decimal/_decimal.c b/Modules/_decimal/_decimal.c
--- a/Modules/_decimal/_decimal.c
+++ b/Modules/_decimal/_decimal.c
@@ -428,7 +428,7 @@
return DEC_INVALID_SIGNALS;
}
- if (PyDict_Size(val) != SIGNAL_MAP_LEN) {
+ if (PyDict_GET_SIZE(val) != SIGNAL_MAP_LEN) {
PyErr_SetString(PyExc_KeyError,
"invalid signal dict");
return DEC_INVALID_SIGNALS;
diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c
--- a/Modules/_elementtree.c
+++ b/Modules/_elementtree.c
@@ -150,7 +150,7 @@
static int
is_empty_dict(PyObject *obj)
{
- return PyDict_CheckExact(obj) && PyDict_Size(obj) == 0;
+ return PyDict_CheckExact(obj) && PyDict_GET_SIZE(obj) == 0;
}
diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c
--- a/Modules/_functoolsmodule.c
+++ b/Modules/_functoolsmodule.c
@@ -84,7 +84,7 @@
}
Py_DECREF(nargs);
- if (pkw == NULL || PyDict_Size(pkw) == 0) {
+ if (pkw == NULL || PyDict_GET_SIZE(pkw) == 0) {
if (kw == NULL) {
pto->kw = PyDict_New();
}
@@ -155,7 +155,7 @@
assert(PyTuple_Check(argappl));
}
- if (PyDict_Size(pto->kw) == 0) {
+ if (PyDict_GET_SIZE(pto->kw) == 0) {
kwappl = kw;
Py_XINCREF(kwappl);
}
@@ -713,7 +713,7 @@
return args;
}
- if (kwds && PyDict_Size(kwds) > 0) {
+ if (kwds && PyDict_GET_SIZE(kwds) > 0) {
sorted_items = PyDict_Items(kwds);
if (!sorted_items)
return NULL;
@@ -933,7 +933,7 @@
}
lru_cache_append_link(self, link);
Py_INCREF(result); /* for return */
- self->full = (PyDict_Size(self->cache) >= self->maxsize);
+ self->full = (PyDict_GET_SIZE(self->cache) >= self->maxsize);
}
self->misses++;
return result;
@@ -1062,7 +1062,7 @@
{
return PyObject_CallFunction(self->cache_info_type, "nnOn",
self->hits, self->misses, self->maxsize_O,
- PyDict_Size(self->cache));
+ PyDict_GET_SIZE(self->cache));
}
static PyObject *
diff --git a/Modules/_operator.c b/Modules/_operator.c
--- a/Modules/_operator.c
+++ b/Modules/_operator.c
@@ -1016,16 +1016,7 @@
return PyUnicode_FromFormat("%s(...)", Py_TYPE(mc)->tp_name);
}
- if (mc->kwds != NULL) {
- numkwdargs = PyDict_Size(mc->kwds);
- if (numkwdargs < 0) {
- Py_ReprLeave((PyObject *)mc);
- return NULL;
- }
- } else {
- numkwdargs = 0;
- }
-
+ numkwdargs = mc->kwds != NULL ? PyDict_GET_SIZE(mc->kwds) : 0;
numposargs = PyTuple_GET_SIZE(mc->args);
numtotalargs = numposargs + numkwdargs;
@@ -1092,7 +1083,7 @@
methodcaller_reduce(methodcallerobject *mc)
{
PyObject *newargs;
- if (!mc->kwds || PyDict_Size(mc->kwds) == 0) {
+ if (!mc->kwds || PyDict_GET_SIZE(mc->kwds) == 0) {
Py_ssize_t i;
Py_ssize_t callargcount = PyTuple_GET_SIZE(mc->args);
newargs = PyTuple_New(1 + callargcount);
diff --git a/Modules/_pickle.c b/Modules/_pickle.c
--- a/Modules/_pickle.c
+++ b/Modules/_pickle.c
@@ -2787,10 +2787,10 @@
const char setitem_op = SETITEM;
const char setitems_op = SETITEMS;
- assert(obj != NULL);
+ assert(obj != NULL && PyDict_CheckExact(obj));
assert(self->proto > 0);
- dict_size = PyDict_Size(obj);
+ dict_size = PyDict_GET_SIZE(obj);
/* Special-case len(d) == 1 to save space. */
if (dict_size == 1) {
@@ -2819,7 +2819,7 @@
}
if (_Pickler_Write(self, &setitems_op, 1) < 0)
return -1;
- if (PyDict_Size(obj) != dict_size) {
+ if (PyDict_GET_SIZE(obj) != dict_size) {
PyErr_Format(
PyExc_RuntimeError,
"dictionary changed size during iteration");
@@ -2837,6 +2837,7 @@
char header[3];
Py_ssize_t len;
int status = 0;
+ assert(PyDict_Check(obj));
if (self->fast && !fast_save_enter(self, obj))
goto error;
@@ -2855,14 +2856,10 @@
if (_Pickler_Write(self, header, len) < 0)
goto error;
- /* Get dict size, and bow out early if empty. */
- if ((len = PyDict_Size(obj)) < 0)
- goto error;
-
if (memo_put(self, obj) < 0)
goto error;
- if (len != 0) {
+ if (PyDict_GET_SIZE(obj)) {
/* Save the dict items. */
if (PyDict_CheckExact(obj) && self->proto > 0) {
/* We can take certain shortcuts if we know this is a dict and
@@ -6878,7 +6875,7 @@
Py_ssize_t i = 0;
PyObject *key, *value;
- new_memo_size = PyDict_Size(obj);
+ new_memo_size = PyDict_GET_SIZE(obj);
new_memo = _Unpickler_NewMemo(new_memo_size);
if (new_memo == NULL)
return -1;
diff --git a/Modules/_sqlite/cache.c b/Modules/_sqlite/cache.c
--- a/Modules/_sqlite/cache.c
+++ b/Modules/_sqlite/cache.c
@@ -162,7 +162,7 @@
* entry in the cache, and make space if necessary by throwing the
* least used item out of the cache. */
- if (PyDict_Size(self->mapping) == self->size) {
+ if (PyDict_GET_SIZE(self->mapping) == self->size) {
if (self->last) {
node = self->last;
diff --git a/Modules/_struct.c b/Modules/_struct.c
--- a/Modules/_struct.c
+++ b/Modules/_struct.c
@@ -2048,7 +2048,7 @@
s_object = PyObject_CallFunctionObjArgs((PyObject *)(&PyStructType), fmt, NULL);
if (s_object != NULL) {
- if (PyDict_Size(cache) >= MAXCACHE)
+ if (PyDict_GET_SIZE(cache) >= MAXCACHE)
PyDict_Clear(cache);
/* Attempt to cache the result */
if (PyDict_SetItem(cache, fmt, s_object) == -1)
diff --git a/Modules/itertoolsmodule.c b/Modules/itertoolsmodule.c
--- a/Modules/itertoolsmodule.c
+++ b/Modules/itertoolsmodule.c
@@ -4180,7 +4180,7 @@
return NULL;
if (kwds != NULL)
- n_kwds = PyDict_Size(kwds);
+ n_kwds = PyDict_GET_SIZE(kwds);
/* Does user supply times argument? */
if ((PyTuple_Size(args) + n_kwds == 2) && cnt < 0)
cnt = 0;
@@ -4331,9 +4331,9 @@
PyObject *fillvalue = Py_None;
Py_ssize_t tuplesize = PySequence_Length(args);
- if (kwds != NULL && PyDict_CheckExact(kwds) && PyDict_Size(kwds) > 0) {
+ if (kwds != NULL && PyDict_CheckExact(kwds) && PyDict_GET_SIZE(kwds) > 0) {
fillvalue = PyDict_GetItemString(kwds, "fillvalue");
- if (fillvalue == NULL || PyDict_Size(kwds) > 1) {
+ if (fillvalue == NULL || PyDict_GET_SIZE(kwds) > 1) {
PyErr_SetString(PyExc_TypeError,
"zip_longest() got an unexpected keyword argument");
return NULL;
diff --git a/Modules/selectmodule.c b/Modules/selectmodule.c
--- a/Modules/selectmodule.c
+++ b/Modules/selectmodule.c
@@ -353,7 +353,7 @@
PyObject *key, *value;
struct pollfd *old_ufds = self->ufds;
- self->ufd_len = PyDict_Size(self->dict);
+ self->ufd_len = PyDict_GET_SIZE(self->dict);
PyMem_RESIZE(self->ufds, struct pollfd, self->ufd_len);
if (self->ufds == NULL) {
self->ufds = old_ufds;
diff --git a/Objects/abstract.c b/Objects/abstract.c
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -2409,8 +2409,7 @@
assert(nargs >= 0);
assert(kwargs == NULL || PyDict_CheckExact(kwargs));
- nkwargs = (kwargs != NULL) ? PyDict_Size(kwargs) : 0;
- if (!nkwargs) {
+ if (kwargs == NULL || (nkwargs = PyDict_GET_SIZE(kwargs)) == 0) {
*p_kwnames = NULL;
return args;
}
diff --git a/Objects/descrobject.c b/Objects/descrobject.c
--- a/Objects/descrobject.c
+++ b/Objects/descrobject.c
@@ -1173,7 +1173,7 @@
return (*wk)(self, args, wp->descr->d_wrapped, kwds);
}
- if (kwds != NULL && (!PyDict_Check(kwds) || PyDict_Size(kwds) != 0)) {
+ if (kwds != NULL && (!PyDict_Check(kwds) || PyDict_GET_SIZE(kwds) != 0)) {
PyErr_Format(PyExc_TypeError,
"wrapper %s doesn't take keyword arguments",
wp->descr->d_base->name);
diff --git a/Objects/funcobject.c b/Objects/funcobject.c
--- a/Objects/funcobject.c
+++ b/Objects/funcobject.c
@@ -583,7 +583,7 @@
if (kw != NULL && PyDict_Check(kw)) {
Py_ssize_t pos, i;
- nk = PyDict_Size(kw);
+ nk = PyDict_GET_SIZE(kw);
kwtuple = PyTuple_New(2*nk);
if (kwtuple == NULL)
return NULL;
diff --git a/Objects/methodobject.c b/Objects/methodobject.c
--- a/Objects/methodobject.c
+++ b/Objects/methodobject.c
@@ -87,6 +87,7 @@
Py_ssize_t size;
int flags;
+ assert(kwds == NULL || PyDict_Check(kwds));
/* PyCFunction_Call() must not be called with an exception set,
because it may clear it (directly or indirectly) and so the
caller loses its exception */
@@ -103,7 +104,7 @@
res = _PyCFunction_FastCallDict(func, stack, nargs, kwds);
}
else {
- if (kwds != NULL && PyDict_Size(kwds) != 0) {
+ if (kwds != NULL && PyDict_GET_SIZE(kwds) != 0) {
PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
f->m_ml->ml_name);
return NULL;
@@ -176,7 +177,7 @@
switch (flags)
{
case METH_NOARGS:
- if (kwargs != NULL && PyDict_Size(kwargs) != 0) {
+ if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) {
PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
func->m_ml->ml_name);
return NULL;
@@ -193,7 +194,7 @@
break;
case METH_O:
- if (kwargs != NULL && PyDict_Size(kwargs) != 0) {
+ if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) {
PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
func->m_ml->ml_name);
return NULL;
@@ -215,7 +216,7 @@
/* Slow-path: create a temporary tuple */
PyObject *tuple;
- if (!(flags & METH_KEYWORDS) && kwargs != NULL && PyDict_Size(kwargs) != 0) {
+ if (!(flags & METH_KEYWORDS) && kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) {
PyErr_Format(PyExc_TypeError,
"%.200s() takes no keyword arguments",
func->m_ml->ml_name);
diff --git a/Objects/object.c b/Objects/object.c
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -1454,7 +1454,7 @@
static PyObject *
none_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_Size(kwargs))) {
+ if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) {
PyErr_SetString(PyExc_TypeError, "NoneType takes no arguments");
return NULL;
}
@@ -1573,7 +1573,7 @@
static PyObject *
notimplemented_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_Size(kwargs))) {
+ if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) {
PyErr_SetString(PyExc_TypeError, "NotImplementedType takes no arguments");
return NULL;
}
diff --git a/Objects/odictobject.c b/Objects/odictobject.c
--- a/Objects/odictobject.c
+++ b/Objects/odictobject.c
@@ -2423,8 +2423,7 @@
/* now handle kwargs */
assert(kwargs == NULL || PyDict_Check(kwargs));
- len = (kwargs != NULL) ? PyDict_Size(kwargs) : 0;
- if (len > 0) {
+ if (kwargs != NULL && PyDict_GET_SIZE(kwargs)) {
PyObject *items = PyDict_Items(kwargs);
if (items == NULL)
return NULL;
diff --git a/Objects/setobject.c b/Objects/setobject.c
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -981,7 +981,7 @@
PyObject *value;
Py_ssize_t pos = 0;
Py_hash_t hash;
- Py_ssize_t dictsize = PyDict_Size(other);
+ Py_ssize_t dictsize = PyDict_GET_SIZE(other);
/* Do one big resize at the start, rather than
* incrementally resizing as we insert new keys. Expect
diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c
--- a/Objects/sliceobject.c
+++ b/Objects/sliceobject.c
@@ -19,7 +19,7 @@
static PyObject *
ellipsis_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_Size(kwargs))) {
+ if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) {
PyErr_SetString(PyExc_TypeError, "EllipsisType takes no arguments");
return NULL;
}
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -902,7 +902,7 @@
if (type == &PyType_Type &&
PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 &&
(kwds == NULL ||
- (PyDict_Check(kwds) && PyDict_Size(kwds) == 0)))
+ (PyDict_Check(kwds) && PyDict_GET_SIZE(kwds) == 0)))
return obj;
/* If the returned object is not an instance of type,
@@ -1585,7 +1585,7 @@
}
}
}
- n = PyDict_Size(set);
+ n = PyDict_GET_SIZE(set);
off = PyOS_snprintf(buf, sizeof(buf), "Cannot create a \
consistent method resolution\norder (MRO) for bases");
@@ -2187,7 +2187,7 @@
assert(kwds == NULL || PyDict_Check(kwds));
if (kwds != NULL && PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 &&
- PyDict_Check(kwds) && PyDict_Size(kwds) != 0) {
+ PyDict_Check(kwds) && PyDict_GET_SIZE(kwds) != 0) {
PyErr_SetString(PyExc_TypeError,
"type.__init__() takes no keyword arguments");
return -1;
@@ -2272,7 +2272,7 @@
Note: We don't call PyType_CheckExact as that also allows subclasses */
if (metatype == &PyType_Type) {
const Py_ssize_t nargs = PyTuple_GET_SIZE(args);
- const Py_ssize_t nkwds = kwds == NULL ? 0 : PyDict_Size(kwds);
+ const Py_ssize_t nkwds = kwds == NULL ? 0 : PyDict_GET_SIZE(kwds);
if (nargs == 1 && nkwds == 0) {
PyObject *x = PyTuple_GET_ITEM(args, 0);
@@ -3416,7 +3416,7 @@
excess_args(PyObject *args, PyObject *kwds)
{
return PyTuple_GET_SIZE(args) ||
- (kwds && PyDict_Check(kwds) && PyDict_Size(kwds));
+ (kwds && PyDict_Check(kwds) && PyDict_GET_SIZE(kwds));
}
static int
@@ -3894,7 +3894,7 @@
We also return None if the dict is empty to make the behavior
consistent regardless whether the dict was initialized or not.
This make unit testing easier. */
- if (dict != NULL && *dict != NULL && PyDict_Size(*dict) > 0) {
+ if (dict != NULL && *dict != NULL && PyDict_GET_SIZE(*dict)) {
state = *dict;
}
else {
@@ -3983,7 +3983,7 @@
/* If we found some slot attributes, pack them in a tuple along
the original attribute dictionary. */
- if (PyDict_Size(slots) > 0) {
+ if (PyDict_GET_SIZE(slots) > 0) {
PyObject *state2;
state2 = PyTuple_Pack(2, state, slots);
@@ -4175,7 +4175,7 @@
return NULL;
}
hasargs = (args != NULL);
- if (kwargs == NULL || PyDict_Size(kwargs) == 0) {
+ if (kwargs == NULL || PyDict_GET_SIZE(kwargs) == 0) {
_Py_IDENTIFIER(__newobj__);
PyObject *cls;
Py_ssize_t i, n;
diff --git a/Python/ceval.c b/Python/ceval.c
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -5010,7 +5010,7 @@
assert(kwargs == NULL || PyDict_Check(kwargs));
if (co->co_kwonlyargcount == 0 &&
- (kwargs == NULL || PyDict_Size(kwargs) == 0) &&
+ (kwargs == NULL || PyDict_GET_SIZE(kwargs) == 0) &&
co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE))
{
/* Fast paths */
@@ -5028,7 +5028,7 @@
if (kwargs != NULL) {
Py_ssize_t pos, i;
- nk = PyDict_Size(kwargs);
+ nk = PyDict_GET_SIZE(kwargs);
kwtuple = PyTuple_New(2 * nk);
if (kwtuple == NULL) {
diff --git a/Python/compile.c b/Python/compile.c
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -564,7 +564,7 @@
PyObject *tuple, *name, *zero;
int res;
assert(u->u_scope_type == COMPILER_SCOPE_CLASS);
- assert(PyDict_Size(u->u_cellvars) == 0);
+ assert(PyDict_GET_SIZE(u->u_cellvars) == 0);
name = _PyUnicode_FromId(&PyId___class__);
if (!name) {
compiler_unit_free(u);
@@ -591,7 +591,7 @@
}
u->u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS,
- PyDict_Size(u->u_cellvars));
+ PyDict_GET_SIZE(u->u_cellvars));
if (!u->u_freevars) {
compiler_unit_free(u);
return 0;
@@ -1128,7 +1128,7 @@
Py_DECREF(t);
return -1;
}
- arg = PyDict_Size(dict);
+ arg = PyDict_GET_SIZE(dict);
v = PyLong_FromSsize_t(arg);
if (!v) {
Py_DECREF(t);
@@ -1999,7 +1999,7 @@
}
else {
/* No methods referenced __class__, so just return None */
- assert(PyDict_Size(c->u->u_cellvars) == 0);
+ assert(PyDict_GET_SIZE(c->u->u_cellvars) == 0);
ADDOP_O(c, LOAD_CONST, Py_None, consts);
}
ADDOP_IN_SCOPE(c, RETURN_VALUE);
@@ -5179,7 +5179,7 @@
dict_keys_inorder(PyObject *dict, Py_ssize_t offset)
{
PyObject *tuple, *k, *v;
- Py_ssize_t i, pos = 0, size = PyDict_Size(dict);
+ Py_ssize_t i, pos = 0, size = PyDict_GET_SIZE(dict);
tuple = PyTuple_New(size);
if (tuple == NULL)
@@ -5203,7 +5203,6 @@
{
PySTEntryObject *ste = c->u->u_ste;
int flags = 0;
- Py_ssize_t n;
if (ste->ste_type == FunctionBlock) {
flags |= CO_NEWLOCALS | CO_OPTIMIZED;
if (ste->ste_nested)
@@ -5223,16 +5222,9 @@
/* (Only) inherit compilerflags in PyCF_MASK */
flags |= (c->c_flags->cf_flags & PyCF_MASK);
- n = PyDict_Size(c->u->u_freevars);
- if (n < 0)
- return -1;
- if (n == 0) {
- n = PyDict_Size(c->u->u_cellvars);
- if (n < 0)
- return -1;
- if (n == 0) {
- flags |= CO_NOFREE;
- }
+ if (!PyDict_GET_SIZE(c->u->u_freevars) &&
+ !PyDict_GET_SIZE(c->u->u_cellvars)) {
+ flags |= CO_NOFREE;
}
return flags;
@@ -5273,7 +5265,7 @@
if (!freevars)
goto error;
- nlocals = PyDict_Size(c->u->u_varnames);
+ nlocals = PyDict_GET_SIZE(c->u->u_varnames);
assert(nlocals < INT_MAX);
nlocals_int = Py_SAFE_DOWNCAST(nlocals, Py_ssize_t, int);
diff --git a/Python/getargs.c b/Python/getargs.c
--- a/Python/getargs.c
+++ b/Python/getargs.c
@@ -1650,7 +1650,7 @@
}
nargs = PyTuple_GET_SIZE(args);
- nkeywords = (keywords == NULL) ? 0 : PyDict_Size(keywords);
+ nkeywords = (keywords == NULL) ? 0 : PyDict_GET_SIZE(keywords);
if (nargs + nkeywords > len) {
PyErr_Format(PyExc_TypeError,
"%s%s takes at most %d argument%s (%zd given)",
@@ -2034,7 +2034,7 @@
}
if (keywords != NULL) {
- nkeywords = PyDict_Size(keywords);
+ nkeywords = PyDict_GET_SIZE(keywords);
}
else if (kwnames != NULL) {
nkeywords = PyTuple_GET_SIZE(kwnames);
@@ -2421,7 +2421,7 @@
PyErr_BadInternalCall();
return 0;
}
- if (PyDict_Size(kw) == 0)
+ if (PyDict_GET_SIZE(kw) == 0)
return 1;
PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",
--
Repository URL: https://hg.python.org/cpython
More information about the Python-checkins
mailing list