PyObject *weakreflist;
};
+#define dequeobject_CAST(op) ((dequeobject *)(op))
+
/* For debug builds, add error checking to track the endpoints
* in the chain of links. The goal is to make sure that link
* assignments only take place at endpoints so that links already
}
static PyObject *
-deque_inplace_concat(dequeobject *deque, PyObject *other)
+deque_inplace_concat(PyObject *self, PyObject *other)
{
+ dequeobject *deque = dequeobject_CAST(self);
PyObject *result;
// deque_extend is thread-safe
/*[clinic end generated code: output=6409b3d1ad2898b5 input=51d2ed1a23bab5e2]*/
{
PyObject *result;
- dequeobject *old_deque = (dequeobject *)deque;
+ dequeobject *old_deque = deque;
collections_state *state = find_module_state_by_def(Py_TYPE(deque));
if (Py_IS_TYPE(deque, state->deque_type)) {
dequeobject *new_deque;
PyObject *rv;
- new_deque = (dequeobject *)deque_new(state->deque_type,
- (PyObject *)NULL, (PyObject *)NULL);
+ new_deque = (dequeobject *)deque_new(state->deque_type, NULL, NULL);
if (new_deque == NULL)
return NULL;
new_deque->maxlen = old_deque->maxlen;
}
static PyObject *
-deque_concat(dequeobject *deque, PyObject *other)
+deque_concat(PyObject *self, PyObject *other)
{
+ dequeobject *deque = dequeobject_CAST(self);
PyObject *result;
Py_BEGIN_CRITICAL_SECTION(deque);
result = deque_concat_lock_held(deque, other);
}
static int
-deque_clear(dequeobject *deque)
+deque_clear(PyObject *self)
{
block *b;
block *prevblock;
Py_ssize_t n, m;
PyObject *item;
PyObject **itemptr, **limit;
+ dequeobject *deque = dequeobject_CAST(self);
if (Py_SIZE(deque) == 0)
return 0;
deque_clearmethod_impl(dequeobject *deque)
/*[clinic end generated code: output=79b2513e097615c1 input=3a22e9605d20c5e9]*/
{
- deque_clear(deque);
+ (void)deque_clear((PyObject *)deque);
Py_RETURN_NONE;
}
}
if (n <= 0) {
- deque_clear(deque);
+ (void)deque_clear((PyObject *)deque);
return Py_NewRef(deque);
}
}
static PyObject *
-deque_inplace_repeat(dequeobject *deque, Py_ssize_t n)
+deque_inplace_repeat(PyObject *self, Py_ssize_t n)
{
+ dequeobject *deque = dequeobject_CAST(self);
PyObject *result;
Py_BEGIN_CRITICAL_SECTION(deque);
result = deque_inplace_repeat_lock_held(deque, n);
}
static PyObject *
-deque_repeat(dequeobject *deque, Py_ssize_t n)
+deque_repeat(PyObject *self, Py_ssize_t n)
{
+ dequeobject *deque = dequeobject_CAST(self);
dequeobject *new_deque;
PyObject *rv;
}
static int
-deque_contains(dequeobject *deque, PyObject *v)
+deque_contains(PyObject *self, PyObject *v)
{
+ dequeobject *deque = dequeobject_CAST(self);
int result;
Py_BEGIN_CRITICAL_SECTION(deque);
result = deque_contains_lock_held(deque, v);
}
static Py_ssize_t
-deque_len(dequeobject *deque)
+deque_len(PyObject *self)
{
- return FT_ATOMIC_LOAD_SSIZE(((PyVarObject *)deque)->ob_size);
+ PyVarObject *deque = _PyVarObject_CAST(self);
+ return FT_ATOMIC_LOAD_SSIZE(deque->ob_size);
}
/*[clinic input]
}
static PyObject *
-deque_item(dequeobject *deque, Py_ssize_t i)
+deque_item(PyObject *self, Py_ssize_t i)
{
+ dequeobject *deque = dequeobject_CAST(self);
PyObject *result;
Py_BEGIN_CRITICAL_SECTION(deque);
result = deque_item_lock_held(deque, i);
}
static int
-deque_ass_item(dequeobject *deque, Py_ssize_t i, PyObject *v)
+deque_ass_item(PyObject *self, Py_ssize_t i, PyObject *v)
{
+ dequeobject *deque = dequeobject_CAST(self);
int result;
Py_BEGIN_CRITICAL_SECTION(deque);
result = deque_ass_item_lock_held(deque, i, v);
}
static void
-deque_dealloc(dequeobject *deque)
+deque_dealloc(PyObject *self)
{
+ dequeobject *deque = dequeobject_CAST(self);
PyTypeObject *tp = Py_TYPE(deque);
Py_ssize_t i;
PyObject_GC_UnTrack(deque);
- if (deque->weakreflist != NULL)
- PyObject_ClearWeakRefs((PyObject *) deque);
+ if (deque->weakreflist != NULL) {
+ PyObject_ClearWeakRefs(self);
+ }
if (deque->leftblock != NULL) {
- deque_clear(deque);
+ (void)deque_clear(self);
assert(deque->leftblock != NULL);
freeblock(deque, deque->leftblock);
}
}
static int
-deque_traverse(dequeobject *deque, visitproc visit, void *arg)
+deque_traverse(PyObject *self, visitproc visit, void *arg)
{
+ dequeobject *deque = dequeobject_CAST(self);
Py_VISIT(Py_TYPE(deque));
block *b;
Py_ReprLeave(deque);
return NULL;
}
- if (((dequeobject *)deque)->maxlen >= 0)
+ Py_ssize_t maxlen = dequeobject_CAST(deque)->maxlen;
+ if (maxlen >= 0)
result = PyUnicode_FromFormat("%s(%R, maxlen=%zd)",
_PyType_Name(Py_TYPE(deque)), aslist,
- ((dequeobject *)deque)->maxlen);
+ maxlen);
else
result = PyUnicode_FromFormat("%s(%R)",
_PyType_Name(Py_TYPE(deque)), aslist);
}
/* Shortcuts */
- vs = Py_SIZE((dequeobject *)v);
- ws = Py_SIZE((dequeobject *)w);
+ vs = Py_SIZE(v);
+ ws = Py_SIZE(w);
if (op == Py_EQ) {
if (v == w)
Py_RETURN_TRUE;
}
deque->maxlen = maxlen;
if (Py_SIZE(deque) > 0)
- deque_clear(deque);
+ (void)deque_clear((PyObject *)deque);
if (iterable != NULL) {
PyObject *rv = deque_extend_impl(deque, iterable);
if (rv == NULL)
}
static PyObject *
-deque_get_maxlen(dequeobject *deque, void *Py_UNUSED(ignored))
+deque_get_maxlen(PyObject *self, void *Py_UNUSED(closure))
{
+ dequeobject *deque = dequeobject_CAST(self);
if (deque->maxlen < 0)
Py_RETURN_NONE;
return PyLong_FromSsize_t(deque->maxlen);
/* deque object ********************************************************/
static PyGetSetDef deque_getset[] = {
- {"maxlen", (getter)deque_get_maxlen, (setter)NULL,
+ {"maxlen", deque_get_maxlen, NULL,
"maximum size of a deque or None if unbounded"},
{0}
};
-static PyObject *deque_iter(dequeobject *deque);
+static PyObject *deque_iter(PyObject *deque);
static PyMethodDef deque_methods[] = {
DEQUE_APPEND_METHODDEF
Py_ssize_t counter; /* number of items remaining for iteration */
} dequeiterobject;
+#define dequeiterobject_CAST(op) ((dequeiterobject *)(op))
+
static PyObject *
-deque_iter(dequeobject *deque)
+deque_iter(PyObject *self)
{
dequeiterobject *it;
+ dequeobject *deque = dequeobject_CAST(self);
collections_state *state = find_module_state_by_def(Py_TYPE(deque));
it = PyObject_GC_New(dequeiterobject, state->dequeiter_type);
}
static int
-dequeiter_traverse(dequeiterobject *dio, visitproc visit, void *arg)
+dequeiter_traverse(PyObject *op, visitproc visit, void *arg)
{
+ dequeiterobject *dio = dequeiterobject_CAST(op);
Py_VISIT(Py_TYPE(dio));
Py_VISIT(dio->deque);
return 0;
}
static int
-dequeiter_clear(dequeiterobject *dio)
+dequeiter_clear(PyObject *op)
{
+ dequeiterobject *dio = dequeiterobject_CAST(op);
Py_CLEAR(dio->deque);
return 0;
}
static void
-dequeiter_dealloc(dequeiterobject *dio)
+dequeiter_dealloc(PyObject *dio)
{
/* bpo-31095: UnTrack is needed before calling any callbacks */
PyTypeObject *tp = Py_TYPE(dio);
}
static PyObject *
-dequeiter_next(dequeiterobject *it)
+dequeiter_next(PyObject *op)
{
PyObject *result;
+ dequeiterobject *it = dequeiterobject_CAST(op);
// It's safe to access it->deque without holding the per-object lock for it
// here; it->deque is only assigned during construction of it.
dequeobject *deque = it->deque;
return NULL;
assert(type == state->dequeiter_type);
- it = (dequeiterobject*)deque_iter((dequeobject *)deque);
+ it = (dequeiterobject*)deque_iter(deque);
if (!it)
return NULL;
/* consume items from the queue */
for(i=0; i<index; i++) {
- PyObject *item = dequeiter_next(it);
+ PyObject *item = dequeiter_next((PyObject *)it);
if (item) {
Py_DECREF(item);
} else {
}
static PyObject *
-dequeiter_len(dequeiterobject *it, PyObject *Py_UNUSED(ignored))
+dequeiter_len(PyObject *op, PyObject *Py_UNUSED(dummy))
{
+ dequeiterobject *it = dequeiterobject_CAST(op);
Py_ssize_t len = FT_ATOMIC_LOAD_SSIZE(it->counter);
return PyLong_FromSsize_t(len);
}
PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
static PyObject *
-dequeiter_reduce(dequeiterobject *it, PyObject *Py_UNUSED(ignored))
+dequeiter_reduce(PyObject *op, PyObject *Py_UNUSED(dummy))
{
+ dequeiterobject *it = dequeiterobject_CAST(op);
PyTypeObject *ty = Py_TYPE(it);
// It's safe to access it->deque without holding the per-object lock for it
// here; it->deque is only assigned during construction of it.
}
static PyMethodDef dequeiter_methods[] = {
- {"__length_hint__", (PyCFunction)dequeiter_len, METH_NOARGS, length_hint_doc},
- {"__reduce__", (PyCFunction)dequeiter_reduce, METH_NOARGS, reduce_doc},
+ {"__length_hint__", dequeiter_len, METH_NOARGS, length_hint_doc},
+ {"__reduce__", dequeiter_reduce, METH_NOARGS, reduce_doc},
{NULL, NULL} /* sentinel */
};
}
static PyObject *
-dequereviter_next(dequeiterobject *it)
+dequereviter_next(PyObject *self)
{
PyObject *item;
+ dequeiterobject *it = dequeiterobject_CAST(self);
// It's safe to access it->deque without holding the per-object lock for it
// here; it->deque is only assigned during construction of it.
dequeobject *deque = it->deque;
return NULL;
/* consume items from the queue */
for(i=0; i<index; i++) {
- PyObject *item = dequereviter_next(it);
+ PyObject *item = dequereviter_next((PyObject *)it);
if (item) {
Py_DECREF(item);
} else {
PyObject *default_factory;
} defdictobject;
+#define defdictobject_CAST(op) ((defdictobject *)(op))
+
static PyType_Spec defdict_spec;
PyDoc_STRVAR(defdict_missing_doc,
");
static PyObject *
-defdict_missing(defdictobject *dd, PyObject *key)
+defdict_missing(PyObject *op, PyObject *key)
{
+ defdictobject *dd = defdictobject_CAST(op);
PyObject *factory = dd->default_factory;
PyObject *value;
if (factory == NULL || factory == Py_None) {
value = _PyObject_CallNoArgs(factory);
if (value == NULL)
return value;
- if (PyObject_SetItem((PyObject *)dd, key, value) < 0) {
+ if (PyObject_SetItem(op, key, value) < 0) {
Py_DECREF(value);
return NULL;
}
}
static inline PyObject*
-new_defdict(defdictobject *dd, PyObject *arg)
+new_defdict(PyObject *op, PyObject *arg)
{
+ defdictobject *dd = defdictobject_CAST(op);
return PyObject_CallFunctionObjArgs((PyObject*)Py_TYPE(dd),
dd->default_factory ? dd->default_factory : Py_None, arg, NULL);
}
PyDoc_STRVAR(defdict_copy_doc, "D.copy() -> a shallow copy of D.");
static PyObject *
-defdict_copy(defdictobject *dd, PyObject *Py_UNUSED(ignored))
+defdict_copy(PyObject *op, PyObject *Py_UNUSED(dummy))
{
/* This calls the object's class. That only works for subclasses
whose class constructor has the same signature. Subclasses that
define a different constructor signature must override copy().
*/
- return new_defdict(dd, (PyObject*)dd);
+ return new_defdict(op, op);
}
static PyObject *
-defdict_reduce(defdictobject *dd, PyObject *Py_UNUSED(ignored))
+defdict_reduce(PyObject *op, PyObject *Py_UNUSED(dummy))
{
/* __reduce__ must return a 5-tuple as follows:
PyObject *items;
PyObject *iter;
PyObject *result;
+ defdictobject *dd = defdictobject_CAST(op);
if (dd->default_factory == NULL || dd->default_factory == Py_None)
args = PyTuple_New(0);
args = PyTuple_Pack(1, dd->default_factory);
if (args == NULL)
return NULL;
- items = PyObject_CallMethodNoArgs((PyObject *)dd, &_Py_ID(items));
+ items = PyObject_CallMethodNoArgs(op, &_Py_ID(items));
if (items == NULL) {
Py_DECREF(args);
return NULL;
}
static PyMethodDef defdict_methods[] = {
- {"__missing__", (PyCFunction)defdict_missing, METH_O,
+ {"__missing__", defdict_missing, METH_O,
defdict_missing_doc},
- {"copy", (PyCFunction)defdict_copy, METH_NOARGS,
+ {"copy", defdict_copy, METH_NOARGS,
defdict_copy_doc},
- {"__copy__", (PyCFunction)defdict_copy, METH_NOARGS,
+ {"__copy__", defdict_copy, METH_NOARGS,
defdict_copy_doc},
- {"__reduce__", (PyCFunction)defdict_reduce, METH_NOARGS,
+ {"__reduce__", defdict_reduce, METH_NOARGS,
reduce_doc},
{"__class_getitem__", Py_GenericAlias, METH_O|METH_CLASS,
PyDoc_STR("See PEP 585")},
};
static void
-defdict_dealloc(defdictobject *dd)
+defdict_dealloc(PyObject *op)
{
+ defdictobject *dd = defdictobject_CAST(op);
/* bpo-31095: UnTrack is needed before calling any callbacks */
PyTypeObject *tp = Py_TYPE(dd);
PyObject_GC_UnTrack(dd);
Py_CLEAR(dd->default_factory);
- PyDict_Type.tp_dealloc((PyObject *)dd);
+ PyDict_Type.tp_dealloc(op);
Py_DECREF(tp);
}
static PyObject *
-defdict_repr(defdictobject *dd)
+defdict_repr(PyObject *op)
{
+ defdictobject *dd = defdictobject_CAST(op);
PyObject *baserepr;
PyObject *defrepr;
PyObject *result;
- baserepr = PyDict_Type.tp_repr((PyObject *)dd);
+ baserepr = PyDict_Type.tp_repr(op);
if (baserepr == NULL)
return NULL;
if (dd->default_factory == NULL)
}
// Like copy(), this calls the object's class.
// Override __or__/__ror__ for subclasses with different constructors.
- PyObject *new = new_defdict((defdictobject*)self, left);
+ PyObject *new = new_defdict(self, left);
if (!new) {
return NULL;
}
}
static int
-defdict_traverse(PyObject *self, visitproc visit, void *arg)
+defdict_traverse(PyObject *op, visitproc visit, void *arg)
{
+ defdictobject *self = defdictobject_CAST(op);
Py_VISIT(Py_TYPE(self));
- Py_VISIT(((defdictobject *)self)->default_factory);
- return PyDict_Type.tp_traverse(self, visit, arg);
+ Py_VISIT(self->default_factory);
+ return PyDict_Type.tp_traverse(op, visit, arg);
}
static int
-defdict_tp_clear(defdictobject *dd)
+defdict_tp_clear(PyObject *op)
{
+ defdictobject *dd = defdictobject_CAST(op);
Py_CLEAR(dd->default_factory);
- return PyDict_Type.tp_clear((PyObject *)dd);
+ return PyDict_Type.tp_clear(op);
}
static int
defdict_init(PyObject *self, PyObject *args, PyObject *kwds)
{
- defdictobject *dd = (defdictobject *)self;
+ defdictobject *dd = defdictobject_CAST(self);
PyObject *olddefault = dd->default_factory;
PyObject *newdefault = NULL;
PyObject *newargs;
PyObject* doc;
} _tuplegetterobject;
+#define tuplegetterobject_CAST(op) ((_tuplegetterobject *)(op))
+
/*[clinic input]
@classmethod
_tuplegetter.__new__ as tuplegetter_new
static PyObject *
tuplegetter_descr_get(PyObject *self, PyObject *obj, PyObject *type)
{
- Py_ssize_t index = ((_tuplegetterobject*)self)->index;
+ Py_ssize_t index = tuplegetterobject_CAST(self)->index;
PyObject *result;
if (obj == NULL) {
static int
tuplegetter_traverse(PyObject *self, visitproc visit, void *arg)
{
- _tuplegetterobject *tuplegetter = (_tuplegetterobject *)self;
+ _tuplegetterobject *tuplegetter = tuplegetterobject_CAST(self);
Py_VISIT(Py_TYPE(tuplegetter));
Py_VISIT(tuplegetter->doc);
return 0;
static int
tuplegetter_clear(PyObject *self)
{
- _tuplegetterobject *tuplegetter = (_tuplegetterobject *)self;
+ _tuplegetterobject *tuplegetter = tuplegetterobject_CAST(self);
Py_CLEAR(tuplegetter->doc);
return 0;
}
static void
-tuplegetter_dealloc(_tuplegetterobject *self)
+tuplegetter_dealloc(PyObject *self)
{
PyTypeObject *tp = Py_TYPE(self);
PyObject_GC_UnTrack(self);
- tuplegetter_clear((PyObject*)self);
- tp->tp_free((PyObject*)self);
+ (void)tuplegetter_clear(self);
+ tp->tp_free(self);
Py_DECREF(tp);
}
static PyObject*
-tuplegetter_reduce(_tuplegetterobject *self, PyObject *Py_UNUSED(ignored))
+tuplegetter_reduce(PyObject *op, PyObject *Py_UNUSED(dummy))
{
- return Py_BuildValue("(O(nO))", (PyObject*) Py_TYPE(self), self->index, self->doc);
+ _tuplegetterobject *self = tuplegetterobject_CAST(op);
+ return Py_BuildValue("(O(nO))", (PyObject *)Py_TYPE(self),
+ self->index, self->doc);
}
static PyObject*
-tuplegetter_repr(_tuplegetterobject *self)
+tuplegetter_repr(PyObject *op)
{
+ _tuplegetterobject *self = tuplegetterobject_CAST(op);
return PyUnicode_FromFormat("%s(%zd, %R)",
_PyType_Name(Py_TYPE(self)),
self->index, self->doc);
};
static PyMethodDef tuplegetter_methods[] = {
- {"__reduce__", (PyCFunction)tuplegetter_reduce, METH_NOARGS, NULL},
+ {"__reduce__", tuplegetter_reduce, METH_NOARGS, NULL},
{NULL},
};
static void
collections_free(void *module)
{
- collections_clear((PyObject *)module);
+ (void)collections_clear((PyObject *)module);
}
PyDoc_STRVAR(collections_doc,
projects / thirdparty / Python / cpython.git / commitdiff
