mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-08-01 15:43:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

PEP 3123: Provide forward compatibility with Python 3.0, while keeping

Browse source 
backwards compatibility. Add Py_Refcnt, Py_Type, Py_Size, and
PyVarObject_HEAD_INIT.
This commit is contained in:
Martin v. Löwis 2007-07-21 06:55:02 +00:00
parent b1994b4a5d
commit 6819210b9e
129 changed files with 1090 additions and 1250 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Objects/boolobject.c
View file

@ -146,8 +146,7 @@ static PyNumberMethods bool_as_number = {
/* The type object for bool. Note that this cannot be subclassed! */
PyTypeObject PyBool_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"bool",
sizeof(PyIntObject),
0,

3
Objects/bufferobject.c
View file

@ -664,8 +664,7 @@ static PyBufferProcs buffer_as_buffer = {
};
PyTypeObject PyBuffer_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"buffer",
sizeof(PyBufferObject),
0,

3
Objects/cellobject.c
View file

@ -99,8 +99,7 @@ static PyGetSetDef cell_getsetlist[] = {
};
PyTypeObject PyCell_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"cell",
sizeof(PyCellObject),
0,

3
Objects/cobject.c
View file

@ -135,8 +135,7 @@ extension modules, so that extension modules can use the Python import\n\
mechanism to link to one another.");
PyTypeObject PyCObject_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /*ob_size*/
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"PyCObject", /*tp_name*/
sizeof(PyCObject), /*tp_basicsize*/
0, /*tp_itemsize*/

3
Objects/codeobject.c
View file

@ -354,8 +354,7 @@ code_hash(PyCodeObject *co)
/* XXX code objects need to participate in GC? */
PyTypeObject PyCode_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"code",
sizeof(PyCodeObject),
0,

3
Objects/complexobject.c
View file

@ -1074,8 +1074,7 @@ static PyNumberMethods complex_as_number = {
};
PyTypeObject PyComplex_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"complex",
sizeof(PyComplexObject),
0,

24
Objects/descrobject.c
View file

@ -382,8 +382,7 @@ descr_traverse(PyObject *self, visitproc visit, void *arg)
}
static PyTypeObject PyMethodDescr_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"method_descriptor",
sizeof(PyMethodDescrObject),
0,
@ -421,8 +420,7 @@ static PyTypeObject PyMethodDescr_Type = {
/* This is for METH_CLASS in C, not for "f = classmethod(f)" in Python! */
static PyTypeObject PyClassMethodDescr_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"classmethod_descriptor",
sizeof(PyMethodDescrObject),
0,
@ -459,8 +457,7 @@ static PyTypeObject PyClassMethodDescr_Type = {
};
static PyTypeObject PyMemberDescr_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"member_descriptor",
sizeof(PyMemberDescrObject),
0,
@ -497,8 +494,7 @@ static PyTypeObject PyMemberDescr_Type = {
};
static PyTypeObject PyGetSetDescr_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"getset_descriptor",
sizeof(PyGetSetDescrObject),
0,
@ -535,8 +531,7 @@ static PyTypeObject PyGetSetDescr_Type = {
};
PyTypeObject PyWrapperDescr_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"wrapper_descriptor",
sizeof(PyWrapperDescrObject),
0,
@ -825,8 +820,7 @@ proxy_richcompare(proxyobject *v, PyObject *w, int op)
}
static PyTypeObject proxytype = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"dictproxy", /* tp_name */
sizeof(proxyobject), /* tp_basicsize */
0, /* tp_itemsize */
@ -1007,8 +1001,7 @@ wrapper_traverse(PyObject *self, visitproc visit, void *arg)
}
static PyTypeObject wrappertype = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"method-wrapper", /* tp_name */
sizeof(wrapperobject), /* tp_basicsize */
0, /* tp_itemsize */
@ -1238,8 +1231,7 @@ property_traverse(PyObject *self, visitproc visit, void *arg)
}
PyTypeObject PyProperty_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"property", /* tp_name */
sizeof(propertyobject), /* tp_basicsize */
0, /* tp_itemsize */

20
Objects/dictobject.c
View file

@ -204,7 +204,7 @@ PyDict_New(void)
if (num_free_dicts) {
mp = free_dicts[--num_free_dicts];
assert (mp != NULL);
assert (mp->ob_type == &PyDict_Type);
assert (Py_Type(mp) == &PyDict_Type);
_Py_NewReference((PyObject *)mp);
if (mp->ma_fill) {
EMPTY_TO_MINSIZE(mp);
@ -849,10 +849,10 @@ dict_dealloc(register dictobject *mp)
}
if (mp->ma_table != mp->ma_smalltable)
PyMem_DEL(mp->ma_table);
if (num_free_dicts < MAXFREEDICTS && mp->ob_type == &PyDict_Type)
if (num_free_dicts < MAXFREEDICTS && Py_Type(mp) == &PyDict_Type)
free_dicts[num_free_dicts++] = mp;
else
mp->ob_type->tp_free((PyObject *)mp);
Py_Type(mp)->tp_free((PyObject *)mp);
Py_TRASHCAN_SAFE_END(mp)
}
@ -1011,7 +1011,7 @@ dict_subscript(dictobject *mp, register PyObject *key)
if (missing_str == NULL)
missing_str =
PyString_InternFromString("__missing__");
missing = _PyType_Lookup(mp->ob_type, missing_str);
missing = _PyType_Lookup(Py_Type(mp), missing_str);
if (missing != NULL)
return PyObject_CallFunctionObjArgs(missing,
(PyObject *)mp, key, NULL);
@ -2119,8 +2119,7 @@ PyDoc_STRVAR(dictionary_doc,
" in the keyword argument list. For example: dict(one=1, two=2)");
PyTypeObject PyDict_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"dict",
sizeof(dictobject),
0,
@ -2302,8 +2301,7 @@ fail:
}
PyTypeObject PyDictIterKey_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"dictionary-keyiterator", /* tp_name */
sizeof(dictiterobject), /* tp_basicsize */
0, /* tp_itemsize */
@ -2375,8 +2373,7 @@ fail:
}
PyTypeObject PyDictIterValue_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"dictionary-valueiterator", /* tp_name */
sizeof(dictiterobject), /* tp_basicsize */
0, /* tp_itemsize */
@ -2462,8 +2459,7 @@ fail:
}
PyTypeObject PyDictIterItem_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"dictionary-itemiterator", /* tp_name */
sizeof(dictiterobject), /* tp_basicsize */
0, /* tp_itemsize */

12
Objects/enumobject.c
View file

@ -43,7 +43,7 @@ enum_dealloc(enumobject *en)
PyObject_GC_UnTrack(en);
Py_XDECREF(en->en_sit);
Py_XDECREF(en->en_result);
en->ob_type->tp_free(en);
Py_Type(en)->tp_free(en);
}
static int
@ -68,7 +68,7 @@ enum_next(enumobject *en)
return NULL;
}
next_item = (*it->ob_type->tp_iternext)(it);
next_item = (*Py_Type(it)->tp_iternext)(it);
if (next_item == NULL)
return NULL;
@ -105,8 +105,7 @@ PyDoc_STRVAR(enum_doc,
"for obtaining an indexed list: (0, seq[0]), (1, seq[1]), (2, seq[2]), ...");
PyTypeObject PyEnum_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"enumerate", /* tp_name */
sizeof(enumobject), /* tp_basicsize */
0, /* tp_itemsize */
@ -195,7 +194,7 @@ reversed_dealloc(reversedobject *ro)
{
PyObject_GC_UnTrack(ro);
Py_XDECREF(ro->seq);
ro->ob_type->tp_free(ro);
Py_Type(ro)->tp_free(ro);
}
static int
@ -253,8 +252,7 @@ static PyMethodDef reversediter_methods[] = {
};
PyTypeObject PyReversed_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"reversed", /* tp_name */
sizeof(reversedobject), /* tp_basicsize */
0, /* tp_itemsize */

24
Objects/exceptions.c
View file

@ -56,7 +56,7 @@ BaseException_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
static int
BaseException_init(PyBaseExceptionObject *self, PyObject *args, PyObject *kwds)
{
if (!_PyArg_NoKeywords(self->ob_type->tp_name, kwds))
if (!_PyArg_NoKeywords(Py_Type(self)->tp_name, kwds))
return -1;
Py_DECREF(self->args);
@ -85,7 +85,7 @@ BaseException_dealloc(PyBaseExceptionObject *self)
{
_PyObject_GC_UNTRACK(self);
BaseException_clear(self);
self->ob_type->tp_free((PyObject *)self);
Py_Type(self)->tp_free((PyObject *)self);
}
static int
@ -129,7 +129,7 @@ BaseException_repr(PyBaseExceptionObject *self)
if (!repr_suffix)
return NULL;
name = (char *)self->ob_type->tp_name;
name = (char *)Py_Type(self)->tp_name;
dot = strrchr(name, '.');
if (dot != NULL) name = dot+1;
@ -148,9 +148,9 @@ static PyObject *
BaseException_reduce(PyBaseExceptionObject *self)
{
if (self->args && self->dict)
return PyTuple_Pack(3, self->ob_type, self->args, self->dict);
return PyTuple_Pack(3, Py_Type(self), self->args, self->dict);
else
return PyTuple_Pack(2, self->ob_type, self->args);
return PyTuple_Pack(2, Py_Type(self), self->args);
}
/*
@ -478,7 +478,7 @@ SystemExit_dealloc(PySystemExitObject *self)
{
_PyObject_GC_UNTRACK(self);
SystemExit_clear(self);
self->ob_type->tp_free((PyObject *)self);
Py_Type(self)->tp_free((PyObject *)self);
}
static int
@ -583,7 +583,7 @@ EnvironmentError_dealloc(PyEnvironmentErrorObject *self)
{
_PyObject_GC_UNTRACK(self);
EnvironmentError_clear(self);
self->ob_type->tp_free((PyObject *)self);
Py_Type(self)->tp_free((PyObject *)self);
}
static int
@ -725,9 +725,9 @@ EnvironmentError_reduce(PyEnvironmentErrorObject *self)
Py_INCREF(args);
if (self->dict)
res = PyTuple_Pack(3, self->ob_type, args, self->dict);
res = PyTuple_Pack(3, Py_Type(self), args, self->dict);
else
res = PyTuple_Pack(2, self->ob_type, args);
res = PyTuple_Pack(2, Py_Type(self), args);
Py_DECREF(args);
return res;
}
@ -780,7 +780,7 @@ WindowsError_dealloc(PyWindowsErrorObject *self)
{
_PyObject_GC_UNTRACK(self);
WindowsError_clear(self);
self->ob_type->tp_free((PyObject *)self);
Py_Type(self)->tp_free((PyObject *)self);
}
static int
@ -1054,7 +1054,7 @@ SyntaxError_dealloc(PySyntaxErrorObject *self)
{
_PyObject_GC_UNTRACK(self);
SyntaxError_clear(self);
self->ob_type->tp_free((PyObject *)self);
Py_Type(self)->tp_free((PyObject *)self);
}
static int
@ -1532,7 +1532,7 @@ UnicodeError_dealloc(PyUnicodeErrorObject *self)
{
_PyObject_GC_UNTRACK(self);
UnicodeError_clear(self);
self->ob_type->tp_free((PyObject *)self);
Py_Type(self)->tp_free((PyObject *)self);
}
static int

5
Objects/fileobject.c
View file

@ -406,7 +406,7 @@ file_dealloc(PyFileObject *f)
Py_XDECREF(f->f_mode);
Py_XDECREF(f->f_encoding);
drop_readahead(f);
f->ob_type->tp_free((PyObject *)f);
Py_Type(f)->tp_free((PyObject *)f);
}
static PyObject *
@ -2077,8 +2077,7 @@ PyDoc_STR(
);
PyTypeObject PyFile_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"file",
sizeof(PyFileObject),
0,

27
Objects/floatobject.c
View file

@ -41,8 +41,8 @@ fill_free_list(void)
p = &((PyFloatBlock *)p)->objects[0];
q = p + N_FLOATOBJECTS;
while (--q > p)
q->ob_type = (struct _typeobject *)(q-1);
q->ob_type = NULL;
Py_Type(q) = (struct _typeobject *)(q-1);
Py_Type(q) = NULL;
return p + N_FLOATOBJECTS - 1;
}
@ -56,7 +56,7 @@ PyFloat_FromDouble(double fval)
}
/* Inline PyObject_New */
op = free_list;
free_list = (PyFloatObject *)op->ob_type;
free_list = (PyFloatObject *)Py_Type(op);
PyObject_INIT(op, &PyFloat_Type);
op->ob_fval = fval;
return (PyObject *) op;
@ -175,11 +175,11 @@ static void
float_dealloc(PyFloatObject *op)
{
if (PyFloat_CheckExact(op)) {
op->ob_type = (struct _typeobject *)free_list;
Py_Type(op) = (struct _typeobject *)free_list;
free_list = op;
}
else
op->ob_type->tp_free((PyObject *)op);
Py_Type(op)->tp_free((PyObject *)op);
}
double
@ -197,7 +197,7 @@ PyFloat_AsDouble(PyObject *op)
return -1;
}
if ((nb = op->ob_type->tp_as_number) == NULL || nb->nb_float == NULL) {
if ((nb = Py_Type(op)->tp_as_number) == NULL || nb->nb_float == NULL) {
PyErr_SetString(PyExc_TypeError, "a float is required");
return -1;
}
@ -986,7 +986,7 @@ float_getformat(PyTypeObject *v, PyObject* arg)
if (!PyString_Check(arg)) {
PyErr_Format(PyExc_TypeError,
"__getformat__() argument must be string, not %.500s",
arg->ob_type->tp_name);
Py_Type(arg)->tp_name);
return NULL;
}
s = PyString_AS_STRING(arg);
@ -1152,8 +1152,7 @@ static PyNumberMethods float_as_number = {
};
PyTypeObject PyFloat_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"float",
sizeof(PyFloatObject),
0,
@ -1265,7 +1264,7 @@ PyFloat_Fini(void)
for (i = 0, p = &list->objects[0];
i < N_FLOATOBJECTS;
i++, p++) {
if (PyFloat_CheckExact(p) && p->ob_refcnt != 0)
if (PyFloat_CheckExact(p) && Py_Refcnt(p) != 0)
frem++;
}
next = list->next;
@ -1276,8 +1275,8 @@ PyFloat_Fini(void)
i < N_FLOATOBJECTS;
i++, p++) {
if (!PyFloat_CheckExact(p) ||
p->ob_refcnt == 0) {
p->ob_type = (struct _typeobject *)
Py_Refcnt(p) == 0) {
Py_Type(p) = (struct _typeobject *)
free_list;
free_list = p;
}
@ -1309,7 +1308,7 @@ PyFloat_Fini(void)
i < N_FLOATOBJECTS;
i++, p++) {
if (PyFloat_CheckExact(p) &&
p->ob_refcnt != 0) {
Py_Refcnt(p) != 0) {
char buf[100];
PyFloat_AsString(buf, p);
/* XXX(twouters) cast refcount to
@ -1318,7 +1317,7 @@ PyFloat_Fini(void)
*/
fprintf(stderr,
"# <float at %p, refcnt=%ld, val=%s>\n",
p, (long)p->ob_refcnt, buf);
p, (long)Py_Refcnt(p), buf);
}
}
list = list->next;

5
Objects/frameobject.c
View file

@ -509,8 +509,7 @@ frame_clear(PyFrameObject *f)
PyTypeObject PyFrame_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"frame",
sizeof(PyFrameObject),
sizeof(PyObject *),
@ -623,7 +622,7 @@ PyFrame_New(PyThreadState *tstate, PyCodeObject *code, PyObject *globals,
--numfree;
f = free_list;
free_list = free_list->f_back;
if (f->ob_size < extras) {
if (Py_Size(f) < extras) {
f = PyObject_GC_Resize(PyFrameObject, f, extras);
if (f == NULL) {
Py_DECREF(builtins);

17
Objects/funcobject.c
View file

@ -544,8 +544,7 @@ func_descr_get(PyObject *func, PyObject *obj, PyObject *type)
}
PyTypeObject PyFunction_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"function",
sizeof(PyFunctionObject),
0,
@ -615,7 +614,7 @@ cm_dealloc(classmethod *cm)
{
_PyObject_GC_UNTRACK((PyObject *)cm);
Py_XDECREF(cm->cm_callable);
cm->ob_type->tp_free((PyObject *)cm);
Py_Type(cm)->tp_free((PyObject *)cm);
}
static int
@ -644,9 +643,9 @@ cm_descr_get(PyObject *self, PyObject *obj, PyObject *type)
return NULL;
}
if (type == NULL)
type = (PyObject *)(obj->ob_type);
type = (PyObject *)(Py_Type(obj));
return PyMethod_New(cm->cm_callable,
type, (PyObject *)(type->ob_type));
type, (PyObject *)(Py_Type(type)));
}
static int
@ -692,8 +691,7 @@ Class methods are different than C++ or Java static methods.\n\
If you want those, see the staticmethod builtin.");
PyTypeObject PyClassMethod_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"classmethod",
sizeof(classmethod),
0,
@ -773,7 +771,7 @@ sm_dealloc(staticmethod *sm)
{
_PyObject_GC_UNTRACK((PyObject *)sm);
Py_XDECREF(sm->sm_callable);
sm->ob_type->tp_free((PyObject *)sm);
Py_Type(sm)->tp_free((PyObject *)sm);
}
static int
@ -840,8 +838,7 @@ Static methods in Python are similar to those found in Java or C++.\n\
For a more advanced concept, see the classmethod builtin.");
PyTypeObject PyStaticMethod_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"staticmethod",
sizeof(staticmethod),
0,

5
Objects/genobject.c
View file

@ -28,7 +28,7 @@ gen_dealloc(PyGenObject *gen)
if (gen->gi_frame != NULL && gen->gi_frame->f_stacktop != NULL) {
/* Generator is paused, so we need to close */
gen->ob_type->tp_del(self);
Py_Type(gen)->tp_del(self);
if (self->ob_refcnt > 0)
return; /* resurrected. :( */
}
@ -296,8 +296,7 @@ static PyMethodDef gen_methods[] = {
};
PyTypeObject PyGen_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"generator", /* tp_name */
sizeof(PyGenObject), /* tp_basicsize */
0, /* tp_itemsize */

27
Objects/intobject.c
View file

@ -56,8 +56,8 @@ fill_free_list(void)
p = &((PyIntBlock *)p)->objects[0];
q = p + N_INTOBJECTS;
while (--q > p)
q->ob_type = (struct _typeobject *)(q-1);
q->ob_type = NULL;
Py_Type(q) = (struct _typeobject *)(q-1);
Py_Type(q) = NULL;
return p + N_INTOBJECTS - 1;
}
@ -102,7 +102,7 @@ PyInt_FromLong(long ival)
}
/* Inline PyObject_New */
v = free_list;
free_list = (PyIntObject *)v->ob_type;
free_list = (PyIntObject *)Py_Type(v);
PyObject_INIT(v, &PyInt_Type);
v->ob_ival = ival;
return (PyObject *) v;
@ -128,17 +128,17 @@ static void
int_dealloc(PyIntObject *v)
{
if (PyInt_CheckExact(v)) {
v->ob_type = (struct _typeobject *)free_list;
Py_Type(v) = (struct _typeobject *)free_list;
free_list = v;
}
else
v->ob_type->tp_free((PyObject *)v);
Py_Type(v)->tp_free((PyObject *)v);
}
static void
int_free(PyIntObject *v)
{
v->ob_type = (struct _typeobject *)free_list;
Py_Type(v) = (struct _typeobject *)free_list;
free_list = v;
}
@ -152,7 +152,7 @@ PyInt_AsLong(register PyObject *op)
if (op && PyInt_Check(op))
return PyInt_AS_LONG((PyIntObject*) op);
if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
if (op == NULL || (nb = Py_Type(op)->tp_as_number) == NULL ||
nb->nb_int == NULL) {
PyErr_SetString(PyExc_TypeError, "an integer is required");
return -1;
@ -207,7 +207,7 @@ PyInt_AsSsize_t(register PyObject *op)
return PyInt_AsLong(op);
#else
if ((nb = op->ob_type->tp_as_number) == NULL ||
if ((nb = Py_Type(op)->tp_as_number) == NULL ||
(nb->nb_int == NULL && nb->nb_long == 0)) {
PyErr_SetString(PyExc_TypeError, "an integer is required");
return -1;
@ -256,7 +256,7 @@ PyInt_AsUnsignedLongMask(register PyObject *op)
if (op && PyLong_Check(op))
return PyLong_AsUnsignedLongMask(op);
if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
if (op == NULL || (nb = Py_Type(op)->tp_as_number) == NULL ||
nb->nb_int == NULL) {
PyErr_SetString(PyExc_TypeError, "an integer is required");
return (unsigned long)-1;
@ -301,7 +301,7 @@ PyInt_AsUnsignedLongLongMask(register PyObject *op)
if (op && PyLong_Check(op))
return PyLong_AsUnsignedLongLongMask(op);
if (op == NULL || (nb = op->ob_type->tp_as_number) == NULL ||
if (op == NULL || (nb = Py_Type(op)->tp_as_number) == NULL ||
nb->nb_int == NULL) {
PyErr_SetString(PyExc_TypeError, "an integer is required");
return (unsigned PY_LONG_LONG)-1;
@ -1116,8 +1116,7 @@ static PyNumberMethods int_as_number = {
};
PyTypeObject PyInt_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"int",
sizeof(PyIntObject),
0,
@ -1170,7 +1169,7 @@ _PyInt_Init(void)
return 0;
/* PyObject_New is inlined */
v = free_list;
free_list = (PyIntObject *)v->ob_type;
free_list = (PyIntObject *)Py_Type(v);
PyObject_INIT(v, &PyInt_Type);
v->ob_ival = ival;
small_ints[ival + NSMALLNEGINTS] = v;
@ -1223,7 +1222,7 @@ PyInt_Fini(void)
ctr++, p++) {
if (!PyInt_CheckExact(p) ||
p->ob_refcnt == 0) {
p->ob_type = (struct _typeobject *)
Py_Type(p) = (struct _typeobject *)
free_list;
free_list = p;
}

6
Objects/iterobject.c
View file

@ -94,8 +94,7 @@ static PyMethodDef seqiter_methods[] = {
};
PyTypeObject PySeqIter_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"iterator", /* tp_name */
sizeof(seqiterobject), /* tp_basicsize */
0, /* tp_itemsize */
@ -199,8 +198,7 @@ calliter_iternext(calliterobject *it)
}
PyTypeObject PyCallIter_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"callable-iterator", /* tp_name */
sizeof(calliterobject), /* tp_basicsize */
0, /* tp_itemsize */

179
Objects/listobject.c
View file

@ -34,7 +34,7 @@ list_resize(PyListObject *self, Py_ssize_t newsize)
*/
if (allocated >= newsize && newsize >= (allocated >> 1)) {
assert(self->ob_item != NULL || newsize == 0);
self->ob_size = newsize;
Py_Size(self) = newsize;
return 0;
}
@ -58,7 +58,7 @@ list_resize(PyListObject *self, Py_ssize_t newsize)
return -1;
}
self->ob_item = items;
self->ob_size = newsize;
Py_Size(self) = newsize;
self->allocated = new_allocated;
return 0;
}
@ -114,7 +114,7 @@ PyList_New(Py_ssize_t size)
}
memset(op->ob_item, 0, nbytes);
}
op->ob_size = size;
Py_Size(op) = size;
op->allocated = size;
_PyObject_GC_TRACK(op);
return (PyObject *) op;
@ -128,7 +128,7 @@ PyList_Size(PyObject *op)
return -1;
}
else
return ((PyListObject *)op) -> ob_size;
return Py_Size(op);
}
static PyObject *indexerr = NULL;
@ -140,7 +140,7 @@ PyList_GetItem(PyObject *op, Py_ssize_t i)
PyErr_BadInternalCall();
return NULL;
}
if (i < 0 || i >= ((PyListObject *)op) -> ob_size) {
if (i < 0 || i >= Py_Size(op)) {
if (indexerr == NULL)
indexerr = PyString_FromString(
"list index out of range");
@ -161,7 +161,7 @@ PyList_SetItem(register PyObject *op, register Py_ssize_t i,
PyErr_BadInternalCall();
return -1;
}
if (i < 0 || i >= ((PyListObject *)op) -> ob_size) {
if (i < 0 || i >= Py_Size(op)) {
Py_XDECREF(newitem);
PyErr_SetString(PyExc_IndexError,
"list assignment index out of range");
@ -177,7 +177,7 @@ PyList_SetItem(register PyObject *op, register Py_ssize_t i,
static int
ins1(PyListObject *self, Py_ssize_t where, PyObject *v)
{
Py_ssize_t i, n = self->ob_size;
Py_ssize_t i, n = Py_Size(self);
PyObject **items;
if (v == NULL) {
PyErr_BadInternalCall();
@ -259,7 +259,7 @@ list_dealloc(PyListObject *op)
There's a simple test case where somehow this reduces
thrashing when a *very* large list is created and
immediately deleted. */
i = op->ob_size;
i = Py_Size(op);
while (--i >= 0) {
Py_XDECREF(op->ob_item[i]);
}
@ -268,7 +268,7 @@ list_dealloc(PyListObject *op)
if (num_free_lists < MAXFREELISTS && PyList_CheckExact(op))
free_lists[num_free_lists++] = op;
else
op->ob_type->tp_free((PyObject *)op);
Py_Type(op)->tp_free((PyObject *)op);
Py_TRASHCAN_SAFE_END(op)
}
@ -286,7 +286,7 @@ list_print(PyListObject *op, FILE *fp, int flags)
return 0;
}
fprintf(fp, "[");
for (i = 0; i < op->ob_size; i++) {
for (i = 0; i < Py_Size(op); i++) {
if (i > 0)
fprintf(fp, ", ");
if (PyObject_Print(op->ob_item[i], fp, 0) != 0) {
@ -311,7 +311,7 @@ list_repr(PyListObject *v)
return i > 0 ? PyString_FromString("[...]") : NULL;
}
if (v->ob_size == 0) {
if (Py_Size(v) == 0) {
result = PyString_FromString("[]");
goto Done;
}
@ -322,7 +322,7 @@ list_repr(PyListObject *v)
/* Do repr() on each element. Note that this may mutate the list,
so must refetch the list size on each iteration. */
for (i = 0; i < v->ob_size; ++i) {
for (i = 0; i < Py_Size(v); ++i) {
int status;
s = PyObject_Repr(v->ob_item[i]);
if (s == NULL)
@ -369,7 +369,7 @@ Done:
static Py_ssize_t
list_length(PyListObject *a)
{
return a->ob_size;
return Py_Size(a);
}
static int
@ -378,7 +378,7 @@ list_contains(PyListObject *a, PyObject *el)
Py_ssize_t i;
int cmp;
for (i = 0, cmp = 0 ; cmp == 0 && i < a->ob_size; ++i)
for (i = 0, cmp = 0 ; cmp == 0 && i < Py_Size(a); ++i)
cmp = PyObject_RichCompareBool(el, PyList_GET_ITEM(a, i),
Py_EQ);
return cmp;
@ -387,7 +387,7 @@ list_contains(PyListObject *a, PyObject *el)
static PyObject *
list_item(PyListObject *a, Py_ssize_t i)
{
if (i < 0 || i >= a->ob_size) {
if (i < 0 || i >= Py_Size(a)) {
if (indexerr == NULL)
indexerr = PyString_FromString(
"list index out of range");
@ -406,12 +406,12 @@ list_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
Py_ssize_t i, len;
if (ilow < 0)
ilow = 0;
else if (ilow > a->ob_size)
ilow = a->ob_size;
else if (ilow > Py_Size(a))
ilow = Py_Size(a);
if (ihigh < ilow)
ihigh = ilow;
else if (ihigh > a->ob_size)
ihigh = a->ob_size;
else if (ihigh > Py_Size(a))
ihigh = Py_Size(a);
len = ihigh - ilow;
np = (PyListObject *) PyList_New(len);
if (np == NULL)
@ -451,7 +451,7 @@ list_concat(PyListObject *a, PyObject *bb)
return NULL;
}
#define b ((PyListObject *)bb)
size = a->ob_size + b->ob_size;
size = Py_Size(a) + Py_Size(b);
if (size < 0)
return PyErr_NoMemory();
np = (PyListObject *) PyList_New(size);
@ -460,14 +460,14 @@ list_concat(PyListObject *a, PyObject *bb)
}
src = a->ob_item;
dest = np->ob_item;
for (i = 0; i < a->ob_size; i++) {
for (i = 0; i < Py_Size(a); i++) {
PyObject *v = src[i];
Py_INCREF(v);
dest[i] = v;
}
src = b->ob_item;
dest = np->ob_item + a->ob_size;
for (i = 0; i < b->ob_size; i++) {
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;
@ -486,17 +486,17 @@ list_repeat(PyListObject *a, Py_ssize_t n)
PyObject *elem;
if (n < 0)
n = 0;
size = a->ob_size * n;
size = Py_Size(a) * n;
if (size == 0)
return PyList_New(0);
if (n && size/n != a->ob_size)
if (n && size/n != Py_Size(a))
return PyErr_NoMemory();
np = (PyListObject *) PyList_New(size);
if (np == NULL)
return NULL;
items = np->ob_item;
if (a->ob_size == 1) {
if (Py_Size(a) == 1) {
elem = a->ob_item[0];
for (i = 0; i < n; i++) {
items[i] = elem;
@ -507,7 +507,7 @@ list_repeat(PyListObject *a, Py_ssize_t n)
p = np->ob_item;
items = a->ob_item;
for (i = 0; i < n; i++) {
for (j = 0; j < a->ob_size; j++) {
for (j = 0; j < Py_Size(a); j++) {
*p = items[j];
Py_INCREF(*p);
p++;
@ -524,8 +524,8 @@ list_clear(PyListObject *a)
if (item != NULL) {
/* Because XDECREF can recursively invoke operations on
this list, we make it empty first. */
i = a->ob_size;
a->ob_size = 0;
i = Py_Size(a);
Py_Size(a) = 0;
a->ob_item = NULL;
a->allocated = 0;
while (--i >= 0) {
@ -571,7 +571,7 @@ list_ass_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
else {
if (a == b) {
/* Special case "a[i:j] = a" -- copy b first */
v = list_slice(b, 0, b->ob_size);
v = list_slice(b, 0, Py_Size(b));
if (v == NULL)
return result;
result = list_ass_slice(a, ilow, ihigh, v);
@ -586,18 +586,18 @@ list_ass_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
}
if (ilow < 0)
ilow = 0;
else if (ilow > a->ob_size)
ilow = a->ob_size;
else if (ilow > Py_Size(a))
ilow = Py_Size(a);
if (ihigh < ilow)
ihigh = ilow;
else if (ihigh > a->ob_size)
ihigh = a->ob_size;
else if (ihigh > Py_Size(a))
ihigh = Py_Size(a);
norig = ihigh - ilow;
assert(norig >= 0);
d = n - norig;
if (a->ob_size + d == 0) {
if (Py_Size(a) + d == 0) {
Py_XDECREF(v_as_SF);
return list_clear(a);
}
@ -615,12 +615,12 @@ list_ass_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
if (d < 0) { /* Delete -d items */
memmove(&item[ihigh+d], &item[ihigh],
(a->ob_size - ihigh)*sizeof(PyObject *));
list_resize(a, a->ob_size + d);
(Py_Size(a) - ihigh)*sizeof(PyObject *));
list_resize(a, Py_Size(a) + d);
item = a->ob_item;
}
else if (d > 0) { /* Insert d items */
k = a->ob_size;
k = Py_Size(a);
if (list_resize(a, k+d) < 0)
goto Error;
item = a->ob_item;
@ -692,7 +692,7 @@ static int
list_ass_item(PyListObject *a, Py_ssize_t i, PyObject *v)
{
PyObject *old_value;
if (i < 0 || i >= a->ob_size) {
if (i < 0 || i >= Py_Size(a)) {
PyErr_SetString(PyExc_IndexError,
"list assignment index out of range");
return -1;
@ -751,7 +751,7 @@ listextend(PyListObject *self, PyObject *b)
Py_DECREF(b);
Py_RETURN_NONE;
}
m = self->ob_size;
m = Py_Size(self);
if (list_resize(self, m + n) == -1) {
Py_DECREF(b);
return NULL;
@ -789,14 +789,14 @@ listextend(PyListObject *self, PyObject *b)
PyErr_Clear();
n = 8; /* arbitrary */
}
m = self->ob_size;
m = Py_Size(self);
mn = m + n;
if (mn >= m) {
/* Make room. */
if (list_resize(self, mn) == -1)
goto error;
/* Make the list sane again. */
self->ob_size = m;
Py_Size(self) = m;
}
/* Else m + n overflowed; on the chance that n lied, and there really
* is enough room, ignore it. If n was telling the truth, we'll
@ -815,10 +815,10 @@ listextend(PyListObject *self, PyObject *b)
}
break;
}
if (self->ob_size < self->allocated) {
if (Py_Size(self) < self->allocated) {
/* steals ref */
PyList_SET_ITEM(self, self->ob_size, item);
++self->ob_size;
PyList_SET_ITEM(self, Py_Size(self), item);
++Py_Size(self);
}
else {
int status = app1(self, item);
@ -829,8 +829,8 @@ listextend(PyListObject *self, PyObject *b)
}
/* Cut back result list if initial guess was too large. */
if (self->ob_size < self->allocated)
list_resize(self, self->ob_size); /* shrinking can't fail */
if (Py_Size(self) < self->allocated)
list_resize(self, Py_Size(self)); /* shrinking can't fail */
Py_DECREF(it);
Py_RETURN_NONE;
@ -869,20 +869,20 @@ listpop(PyListObject *self, PyObject *args)
if (!PyArg_ParseTuple(args, "|n:pop", &i))
return NULL;
if (self->ob_size == 0) {
if (Py_Size(self) == 0) {
/* Special-case most common failure cause */
PyErr_SetString(PyExc_IndexError, "pop from empty list");
return NULL;
}
if (i < 0)
i += self->ob_size;
if (i < 0 || i >= self->ob_size) {
i += Py_Size(self);
if (i < 0 || i >= Py_Size(self)) {
PyErr_SetString(PyExc_IndexError, "pop index out of range");
return NULL;
}
v = self->ob_item[i];
if (i == self->ob_size - 1) {
status = list_resize(self, self->ob_size - 1);
if (i == Py_Size(self) - 1) {
status = list_resize(self, Py_Size(self) - 1);
assert(status >= 0);
return v; /* and v now owns the reference the list had */
}
@ -1812,8 +1812,7 @@ static void
sortwrapper_dealloc(sortwrapperobject *);
static PyTypeObject sortwrapper_type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"sortwrapper", /* tp_name */
sizeof(sortwrapperobject), /* tp_basicsize */
0, /* tp_itemsize */
@ -1930,8 +1929,7 @@ cmpwrapper_call(cmpwrapperobject *co, PyObject *args, PyObject *kwds)
PyDoc_STRVAR(cmpwrapper_doc, "cmp() wrapper for sort with custom keys.");
static PyTypeObject cmpwrapper_type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"cmpwrapper", /* tp_name */
sizeof(cmpwrapperobject), /* tp_basicsize */
0, /* tp_itemsize */
@ -2014,10 +2012,10 @@ listsort(PyListObject *self, PyObject *args, PyObject *kwds)
* sorting (allowing mutations during sorting is a core-dump
* factory, since ob_item may change).
*/
saved_ob_size = self->ob_size;
saved_ob_size = Py_Size(self);
saved_ob_item = self->ob_item;
saved_allocated = self->allocated;
self->ob_size = 0;
Py_Size(self) = 0;
self->ob_item = NULL;
self->allocated = -1; /* any operation will reset it to >= 0 */
@ -2123,8 +2121,8 @@ fail:
dsu_fail:
final_ob_item = self->ob_item;
i = self->ob_size;
self->ob_size = saved_ob_size;
i = Py_Size(self);
Py_Size(self) = saved_ob_size;
self->ob_item = saved_ob_item;
self->allocated = saved_allocated;
if (final_ob_item != NULL) {
@ -2159,8 +2157,8 @@ PyList_Sort(PyObject *v)
static PyObject *
listreverse(PyListObject *self)
{
if (self->ob_size > 1)
reverse_slice(self->ob_item, self->ob_item + self->ob_size);
if (Py_Size(self) > 1)
reverse_slice(self->ob_item, self->ob_item + Py_Size(self));
Py_RETURN_NONE;
}
@ -2173,8 +2171,8 @@ PyList_Reverse(PyObject *v)
PyErr_BadInternalCall();
return -1;
}
if (self->ob_size > 1)
reverse_slice(self->ob_item, self->ob_item + self->ob_size);
if (Py_Size(self) > 1)
reverse_slice(self->ob_item, self->ob_item + Py_Size(self));
return 0;
}
@ -2188,7 +2186,7 @@ PyList_AsTuple(PyObject *v)
PyErr_BadInternalCall();
return NULL;
}
n = ((PyListObject *)v)->ob_size;
n = Py_Size(v);
w = PyTuple_New(n);
if (w == NULL)
return NULL;
@ -2206,7 +2204,7 @@ PyList_AsTuple(PyObject *v)
static PyObject *
listindex(PyListObject *self, PyObject *args)
{
Py_ssize_t i, start=0, stop=self->ob_size;
Py_ssize_t i, start=0, stop=Py_Size(self);
PyObject *v;
if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,
@ -2214,16 +2212,16 @@ listindex(PyListObject *self, PyObject *args)
_PyEval_SliceIndex, &stop))
return NULL;
if (start < 0) {
start += self->ob_size;
start += Py_Size(self);
if (start < 0)
start = 0;
}
if (stop < 0) {
stop += self->ob_size;
stop += Py_Size(self);
if (stop < 0)
stop = 0;
}
for (i = start; i < stop && i < self->ob_size; i++) {
for (i = start; i < stop && i < Py_Size(self); i++) {
int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
if (cmp > 0)
return PyInt_FromSsize_t(i);
@ -2240,7 +2238,7 @@ listcount(PyListObject *self, PyObject *v)
Py_ssize_t count = 0;
Py_ssize_t i;
for (i = 0; i < self->ob_size; i++) {
for (i = 0; i < Py_Size(self); i++) {
int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
if (cmp > 0)
count++;
@ -2255,7 +2253,7 @@ listremove(PyListObject *self, PyObject *v)
{
Py_ssize_t i;
for (i = 0; i < self->ob_size; i++) {
for (i = 0; i < Py_Size(self); i++) {
int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
if (cmp > 0) {
if (list_ass_slice(self, i, i+1,
@ -2275,7 +2273,7 @@ list_traverse(PyListObject *o, visitproc visit, void *arg)
{
Py_ssize_t i;
for (i = o->ob_size; --i >= 0; )
for (i = Py_Size(o); --i >= 0; )
Py_VISIT(o->ob_item[i]);
return 0;
}
@ -2294,7 +2292,7 @@ list_richcompare(PyObject *v, PyObject *w, int op)
vl = (PyListObject *)v;
wl = (PyListObject *)w;
if (vl->ob_size != wl->ob_size && (op == Py_EQ || op == Py_NE)) {
if (Py_Size(vl) != Py_Size(wl) && (op == Py_EQ || op == Py_NE)) {
/* Shortcut: if the lengths differ, the lists differ */
PyObject *res;
if (op == Py_EQ)
@ -2306,7 +2304,7 @@ list_richcompare(PyObject *v, PyObject *w, int op)
}
/* Search for the first index where items are different */
for (i = 0; i < vl->ob_size && i < wl->ob_size; i++) {
for (i = 0; i < Py_Size(vl) && i < Py_Size(wl); i++) {
int k = PyObject_RichCompareBool(vl->ob_item[i],
wl->ob_item[i], Py_EQ);
if (k < 0)
@ -2315,10 +2313,10 @@ list_richcompare(PyObject *v, PyObject *w, int op)
break;
}
if (i >= vl->ob_size || i >= wl->ob_size) {
if (i >= Py_Size(vl) || i >= Py_Size(wl)) {
/* No more items to compare -- compare sizes */
Py_ssize_t vs = vl->ob_size;
Py_ssize_t ws = wl->ob_size;
Py_ssize_t vs = Py_Size(vl);
Py_ssize_t ws = Py_Size(wl);
int cmp;
PyObject *res;
switch (op) {
@ -2362,8 +2360,8 @@ list_init(PyListObject *self, PyObject *args, PyObject *kw)
return -1;
/* Verify list invariants established by PyType_GenericAlloc() */
assert(0 <= self->ob_size);
assert(self->ob_size <= self->allocated || self->allocated == -1);
assert(0 <= Py_Size(self));
assert(Py_Size(self) <= self->allocated || self->allocated == -1);
assert(self->ob_item != NULL ||
self->allocated == 0 || self->allocated == -1);
@ -2467,7 +2465,7 @@ list_subscript(PyListObject* self, PyObject* item)
PyObject* it;
PyObject **src, **dest;
if (PySlice_GetIndicesEx((PySliceObject*)item, self->ob_size,
if (PySlice_GetIndicesEx((PySliceObject*)item, Py_Size(self),
&start, &stop, &step, &slicelength) < 0) {
return NULL;
}
@ -2513,7 +2511,7 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
if (PySlice_GetIndicesEx((PySliceObject*)item, self->ob_size,
if (PySlice_GetIndicesEx((PySliceObject*)item, Py_Size(self),
&start, &stop, &step, &slicelength) < 0) {
return -1;
}
@ -2552,8 +2550,8 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
garbage[i] = PyList_GET_ITEM(self, cur);
if (cur + step >= self->ob_size) {
lim = self->ob_size - cur - 1;
if (cur + step >= Py_Size(self)) {
lim = Py_Size(self) - cur - 1;
}
memmove(self->ob_item + cur - i,
@ -2562,13 +2560,13 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
}
for (cur = start + slicelength*step + 1;
cur < self->ob_size; cur++) {
cur < Py_Size(self); cur++) {
PyList_SET_ITEM(self, cur - slicelength,
PyList_GET_ITEM(self, cur));
}
self->ob_size -= slicelength;
list_resize(self, self->ob_size);
Py_Size(self) -= slicelength;
list_resize(self, Py_Size(self));
for (i = 0; i < slicelength; i++) {
Py_DECREF(garbage[i]);
@ -2651,8 +2649,7 @@ static PyMappingMethods list_as_mapping = {
};
PyTypeObject PyList_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"list",
sizeof(PyListObject),
0,
@ -2717,8 +2714,7 @@ static PyMethodDef listiter_methods[] = {
};
PyTypeObject PyListIter_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"listiterator", /* tp_name */
sizeof(listiterobject), /* tp_basicsize */
0, /* tp_itemsize */
@ -2840,8 +2836,7 @@ static PySequenceMethods listreviter_as_sequence = {
};
PyTypeObject PyListRevIter_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"listreverseiterator", /* tp_name */
sizeof(listreviterobject), /* tp_basicsize */
0, /* tp_itemsize */

178
Objects/longobject.c
View file

@ -50,13 +50,13 @@ static PyObject *long_format(PyObject *aa, int base, int addL);
static PyLongObject *
long_normalize(register PyLongObject *v)
{
Py_ssize_t j = ABS(v->ob_size);
Py_ssize_t j = ABS(Py_Size(v));
Py_ssize_t i = j;
while (i > 0 && v->ob_digit[i-1] == 0)
--i;
if (i != j)
v->ob_size = (v->ob_size < 0) ? -(i) : i;
Py_Size(v) = (Py_Size(v) < 0) ? -(i) : i;
return v;
}
@ -147,7 +147,7 @@ PyLong_FromUnsignedLong(unsigned long ival)
v = _PyLong_New(ndigits);
if (v != NULL) {
digit *p = v->ob_digit;
v->ob_size = ndigits;
Py_Size(v) = ndigits;
while (ival) {
*p++ = (digit)(ival & MASK);
ival >>= SHIFT;
@ -189,7 +189,7 @@ PyLong_FromDouble(double dval)
frac = ldexp(frac, SHIFT);
}
if (neg)
v->ob_size = -(v->ob_size);
Py_Size(v) = -(Py_Size(v));
return (PyObject *)v;
}
@ -323,7 +323,7 @@ PyLong_AsUnsignedLong(PyObject *vv)
return (unsigned long) -1;
}
v = (PyLongObject *)vv;
i = v->ob_size;
i = Py_Size(v);
x = 0;
if (i < 0) {
PyErr_SetString(PyExc_OverflowError,
@ -381,7 +381,7 @@ _PyLong_Sign(PyObject *vv)
assert(v != NULL);
assert(PyLong_Check(v));
return v->ob_size == 0 ? 0 : (v->ob_size < 0 ? -1 : 1);
return Py_Size(v) == 0 ? 0 : (Py_Size(v) < 0 ? -1 : 1);
}
size_t
@ -393,7 +393,7 @@ _PyLong_NumBits(PyObject *vv)
assert(v != NULL);
assert(PyLong_Check(v));
ndigits = ABS(v->ob_size);
ndigits = ABS(Py_Size(v));
assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0);
if (ndigits > 0) {
digit msd = v->ob_digit[ndigits - 1];
@ -519,7 +519,7 @@ _PyLong_FromByteArray(const unsigned char* bytes, size_t n,
}
}
v->ob_size = is_signed ? -idigit : idigit;
Py_Size(v) = is_signed ? -idigit : idigit;
return (PyObject *)long_normalize(v);
}
@ -540,8 +540,8 @@ _PyLong_AsByteArray(PyLongObject* v,
assert(v != NULL && PyLong_Check(v));
if (v->ob_size < 0) {
ndigits = -(v->ob_size);
if (Py_Size(v) < 0) {
ndigits = -(Py_Size(v));
if (!is_signed) {
PyErr_SetString(PyExc_TypeError,
"can't convert negative long to unsigned");
@ -550,7 +550,7 @@ _PyLong_AsByteArray(PyLongObject* v,
do_twos_comp = 1;
}
else {
ndigits = v->ob_size;
ndigits = Py_Size(v);
do_twos_comp = 0;
}
@ -686,7 +686,7 @@ _PyLong_AsScaledDouble(PyObject *vv, int *exponent)
return -1;
}
v = (PyLongObject *)vv;
i = v->ob_size;
i = Py_Size(v);
sign = 1;
if (i < 0) {
sign = -1;
@ -847,7 +847,7 @@ PyLong_FromLongLong(PY_LONG_LONG ival)
v = _PyLong_New(ndigits);
if (v != NULL) {
digit *p = v->ob_digit;
v->ob_size = negative ? -ndigits : ndigits;
Py_Size(v) = negative ? -ndigits : ndigits;
t = (unsigned PY_LONG_LONG)ival;
while (t) {
*p++ = (digit)(t & MASK);
@ -875,7 +875,7 @@ PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival)
v = _PyLong_New(ndigits);
if (v != NULL) {
digit *p = v->ob_digit;
v->ob_size = ndigits;
Py_Size(v) = ndigits;
while (ival) {
*p++ = (digit)(ival & MASK);
ival >>= SHIFT;
@ -1117,7 +1117,7 @@ mul1(PyLongObject *a, wdigit n)
static PyLongObject *
muladd1(PyLongObject *a, wdigit n, wdigit extra)
{
Py_ssize_t size_a = ABS(a->ob_size);
Py_ssize_t size_a = ABS(Py_Size(a));
PyLongObject *z = _PyLong_New(size_a+1);
twodigits carry = extra;
Py_ssize_t i;
@ -1163,7 +1163,7 @@ inplace_divrem1(digit *pout, digit *pin, Py_ssize_t size, digit n)
static PyLongObject *
divrem1(PyLongObject *a, digit n, digit *prem)
{
const Py_ssize_t size = ABS(a->ob_size);
const Py_ssize_t size = ABS(Py_Size(a));
PyLongObject *z;
assert(n > 0 && n <= MASK);
@ -1194,7 +1194,7 @@ long_format(PyObject *aa, int base, int addL)
return NULL;
}
assert(base >= 2 && base <= 36);
size_a = ABS(a->ob_size);
size_a = ABS(Py_Size(a));
/* Compute a rough upper bound for the length of the string */
i = base;
@ -1597,7 +1597,7 @@ digit beyond the first.
z = _PyLong_New(size_z);
if (z == NULL)
return NULL;
z->ob_size = 0;
Py_Size(z) = 0;
/* `convwidth` consecutive input digits are treated as a single
* digit in base `convmultmax`.
@ -1627,7 +1627,7 @@ digit beyond the first.
/* Multiply z by convmult, and add c. */
pz = z->ob_digit;
pzstop = pz + z->ob_size;
pzstop = pz + Py_Size(z);
for (; pz < pzstop; ++pz) {
c += (twodigits)*pz * convmult;
*pz = (digit)(c & MASK);
@ -1636,14 +1636,14 @@ digit beyond the first.
/* carry off the current end? */
if (c) {
assert(c < BASE);
if (z->ob_size < size_z) {
if (Py_Size(z) < size_z) {
*pz = (digit)c;
++z->ob_size;
++Py_Size(z);
}
else {
PyLongObject *tmp;
/* Extremely rare. Get more space. */
assert(z->ob_size == size_z);
assert(Py_Size(z) == size_z);
tmp = _PyLong_New(size_z + 1);
if (tmp == NULL) {
Py_DECREF(z);
@ -1665,7 +1665,7 @@ digit beyond the first.
if (str == start)
goto onError;
if (sign < 0)
z->ob_size = -(z->ob_size);
Py_Size(z) = -(Py_Size(z));
if (*str == 'L' || *str == 'l')
str++;
while (*str && isspace(Py_CHARMASK(*str)))
@ -1726,7 +1726,7 @@ static int
long_divrem(PyLongObject *a, PyLongObject *b,
PyLongObject **pdiv, PyLongObject **prem)
{
Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
Py_ssize_t size_a = ABS(Py_Size(a)), size_b = ABS(Py_Size(b));
PyLongObject *z;
if (size_b == 0) {
@ -1778,7 +1778,7 @@ long_divrem(PyLongObject *a, PyLongObject *b,
static PyLongObject *
x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
{
Py_ssize_t size_v = ABS(v1->ob_size), size_w = ABS(w1->ob_size);
Py_ssize_t size_v = ABS(Py_Size(v1)), size_w = ABS(Py_Size(w1));
digit d = (digit) ((twodigits)BASE / (w1->ob_digit[size_w-1] + 1));
PyLongObject *v = mul1(v1, d);
PyLongObject *w = mul1(w1, d);
@ -1792,10 +1792,10 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
}
assert(size_v >= size_w && size_w > 1); /* Assert checks by div() */
assert(v->ob_refcnt == 1); /* Since v will be used as accumulator! */
assert(size_w == ABS(w->ob_size)); /* That's how d was calculated */
assert(Py_Refcnt(v) == 1); /* Since v will be used as accumulator! */
assert(size_w == ABS(Py_Size(w))); /* That's how d was calculated */
size_v = ABS(v->ob_size);
size_v = ABS(Py_Size(v));
k = size_v - size_w;
a = _PyLong_New(k + 1);
@ -1878,7 +1878,7 @@ x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
static void
long_dealloc(PyObject *v)
{
v->ob_type->tp_free(v);
Py_Type(v)->tp_free(v);
}
static PyObject *
@ -1898,21 +1898,21 @@ long_compare(PyLongObject *a, PyLongObject *b)
{
Py_ssize_t sign;
if (a->ob_size != b->ob_size) {
if (ABS(a->ob_size) == 0 && ABS(b->ob_size) == 0)
if (Py_Size(a) != Py_Size(b)) {
if (ABS(Py_Size(a)) == 0 && ABS(Py_Size(b)) == 0)
sign = 0;
else
sign = a->ob_size - b->ob_size;
sign = Py_Size(a) - Py_Size(b);
}
else {
Py_ssize_t i = ABS(a->ob_size);
Py_ssize_t i = ABS(Py_Size(a));
while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
;
if (i < 0)
sign = 0;
else {
sign = (int)a->ob_digit[i] - (int)b->ob_digit[i];
if (a->ob_size < 0)
if (Py_Size(a) < 0)
sign = -sign;
}
}
@ -1955,7 +1955,7 @@ long_hash(PyLongObject *v)
static PyLongObject *
x_add(PyLongObject *a, PyLongObject *b)
{
Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
Py_ssize_t size_a = ABS(Py_Size(a)), size_b = ABS(Py_Size(b));
PyLongObject *z;
int i;
digit carry = 0;
@ -1989,7 +1989,7 @@ x_add(PyLongObject *a, PyLongObject *b)
static PyLongObject *
x_sub(PyLongObject *a, PyLongObject *b)
{
Py_ssize_t size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
Py_ssize_t size_a = ABS(Py_Size(a)), size_b = ABS(Py_Size(b));
PyLongObject *z;
Py_ssize_t i;
int sign = 1;
@ -2099,15 +2099,15 @@ static PyLongObject *
x_mul(PyLongObject *a, PyLongObject *b)
{
PyLongObject *z;
Py_ssize_t size_a = ABS(a->ob_size);
Py_ssize_t size_b = ABS(b->ob_size);
Py_ssize_t size_a = ABS(Py_Size(a));
Py_ssize_t size_b = ABS(Py_Size(b));
Py_ssize_t i;
z = _PyLong_New(size_a + size_b);
if (z == NULL)
return NULL;
memset(z->ob_digit, 0, z->ob_size * sizeof(digit));
memset(z->ob_digit, 0, Py_Size(z) * sizeof(digit));
if (a == b) {
/* Efficient squaring per HAC, Algorithm 14.16:
* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf
@ -2191,7 +2191,7 @@ kmul_split(PyLongObject *n, Py_ssize_t size, PyLongObject **high, PyLongObject *
{
PyLongObject *hi, *lo;
Py_ssize_t size_lo, size_hi;
const Py_ssize_t size_n = ABS(n->ob_size);
const Py_ssize_t size_n = ABS(Py_Size(n));
size_lo = MIN(size_n, size);
size_hi = size_n - size_lo;
@ -2220,8 +2220,8 @@ static PyLongObject *k_lopsided_mul(PyLongObject *a, PyLongObject *b);
static PyLongObject *
k_mul(PyLongObject *a, PyLongObject *b)
{
Py_ssize_t asize = ABS(a->ob_size);
Py_ssize_t bsize = ABS(b->ob_size);
Py_ssize_t asize = ABS(Py_Size(a));
Py_ssize_t bsize = ABS(Py_Size(b));
PyLongObject *ah = NULL;
PyLongObject *al = NULL;
PyLongObject *bh = NULL;
@ -2273,7 +2273,7 @@ k_mul(PyLongObject *a, PyLongObject *b)
/* Split a & b into hi & lo pieces. */
shift = bsize >> 1;
if (kmul_split(a, shift, &ah, &al) < 0) goto fail;
assert(ah->ob_size > 0); /* the split isn't degenerate */
assert(Py_Size(ah) > 0); /* the split isn't degenerate */
if (a == b) {
bh = ah;
@ -2304,20 +2304,20 @@ k_mul(PyLongObject *a, PyLongObject *b)
if (ret == NULL) goto fail;
#ifdef Py_DEBUG
/* Fill with trash, to catch reference to uninitialized digits. */
memset(ret->ob_digit, 0xDF, ret->ob_size * sizeof(digit));
memset(ret->ob_digit, 0xDF, Py_Size(ret) * sizeof(digit));
#endif
/* 2. t1 <- ah*bh, and copy into high digits of result. */
if ((t1 = k_mul(ah, bh)) == NULL) goto fail;
assert(t1->ob_size >= 0);
assert(2*shift + t1->ob_size <= ret->ob_size);
assert(Py_Size(t1) >= 0);
assert(2*shift + Py_Size(t1) <= Py_Size(ret));
memcpy(ret->ob_digit + 2*shift, t1->ob_digit,
t1->ob_size * sizeof(digit));
Py_Size(t1) * sizeof(digit));
/* Zero-out the digits higher than the ah*bh copy. */
i = ret->ob_size - 2*shift - t1->ob_size;
i = Py_Size(ret) - 2*shift - Py_Size(t1);
if (i)
memset(ret->ob_digit + 2*shift + t1->ob_size, 0,
memset(ret->ob_digit + 2*shift + Py_Size(t1), 0,
i * sizeof(digit));
/* 3. t2 <- al*bl, and copy into the low digits. */
@ -2325,23 +2325,23 @@ k_mul(PyLongObject *a, PyLongObject *b)
Py_DECREF(t1);
goto fail;
}
assert(t2->ob_size >= 0);
assert(t2->ob_size <= 2*shift); /* no overlap with high digits */
memcpy(ret->ob_digit, t2->ob_digit, t2->ob_size * sizeof(digit));
assert(Py_Size(t2) >= 0);
assert(Py_Size(t2) <= 2*shift); /* no overlap with high digits */
memcpy(ret->ob_digit, t2->ob_digit, Py_Size(t2) * sizeof(digit));
/* Zero out remaining digits. */
i = 2*shift - t2->ob_size; /* number of uninitialized digits */
i = 2*shift - Py_Size(t2); /* number of uninitialized digits */
if (i)
memset(ret->ob_digit + t2->ob_size, 0, i * sizeof(digit));
memset(ret->ob_digit + Py_Size(t2), 0, i * sizeof(digit));
/* 4 & 5. Subtract ah*bh (t1) and al*bl (t2). We do al*bl first
* because it's fresher in cache.
*/
i = ret->ob_size - shift; /* # digits after shift */
(void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, t2->ob_size);
i = Py_Size(ret) - shift; /* # digits after shift */
(void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, Py_Size(t2));
Py_DECREF(t2);
(void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, t1->ob_size);
(void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, Py_Size(t1));
Py_DECREF(t1);
/* 6. t3 <- (ah+al)(bh+bl), and add into result. */
@ -2366,12 +2366,12 @@ k_mul(PyLongObject *a, PyLongObject *b)
Py_DECREF(t1);
Py_DECREF(t2);
if (t3 == NULL) goto fail;
assert(t3->ob_size >= 0);
assert(Py_Size(t3) >= 0);
/* Add t3. It's not obvious why we can't run out of room here.
* See the (*) comment after this function.
*/
(void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, t3->ob_size);
(void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, Py_Size(t3));
Py_DECREF(t3);
return long_normalize(ret);
@ -2441,8 +2441,8 @@ ah*bh and al*bl too.
static PyLongObject *
k_lopsided_mul(PyLongObject *a, PyLongObject *b)
{
const Py_ssize_t asize = ABS(a->ob_size);
Py_ssize_t bsize = ABS(b->ob_size);
const Py_ssize_t asize = ABS(Py_Size(a));
Py_ssize_t bsize = ABS(Py_Size(b));
Py_ssize_t nbdone; /* # of b digits already multiplied */
PyLongObject *ret;
PyLongObject *bslice = NULL;
@ -2454,7 +2454,7 @@ k_lopsided_mul(PyLongObject *a, PyLongObject *b)
ret = _PyLong_New(asize + bsize);
if (ret == NULL)
return NULL;
memset(ret->ob_digit, 0, ret->ob_size * sizeof(digit));
memset(ret->ob_digit, 0, Py_Size(ret) * sizeof(digit));
/* Successive slices of b are copied into bslice. */
bslice = _PyLong_New(asize);
@ -2469,14 +2469,14 @@ k_lopsided_mul(PyLongObject *a, PyLongObject *b)
/* Multiply the next slice of b by a. */
memcpy(bslice->ob_digit, b->ob_digit + nbdone,
nbtouse * sizeof(digit));
bslice->ob_size = nbtouse;
Py_Size(bslice) = nbtouse;
product = k_mul(a, bslice);
if (product == NULL)
goto fail;
/* Add into result. */
(void)v_iadd(ret->ob_digit + nbdone, ret->ob_size - nbdone,
product->ob_digit, product->ob_size);
(void)v_iadd(ret->ob_digit + nbdone, Py_Size(ret) - nbdone,
product->ob_digit, Py_Size(product));
Py_DECREF(product);
bsize -= nbtouse;
@ -2540,8 +2540,8 @@ l_divmod(PyLongObject *v, PyLongObject *w,
if (long_divrem(v, w, &div, &mod) < 0)
return -1;
if ((mod->ob_size < 0 && w->ob_size > 0) ||
(mod->ob_size > 0 && w->ob_size < 0)) {
if ((Py_Size(mod) < 0 && Py_Size(w) > 0) ||
(Py_Size(mod) > 0 && Py_Size(w) < 0)) {
PyLongObject *temp;
PyLongObject *one;
temp = (PyLongObject *) long_add(mod, w);
@ -2729,7 +2729,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
return Py_NotImplemented;
}
if (b->ob_size < 0) { /* if exponent is negative */
if (Py_Size(b) < 0) { /* if exponent is negative */
if (c) {
PyErr_SetString(PyExc_TypeError, "pow() 2nd argument "
"cannot be negative when 3rd argument specified");
@ -2748,7 +2748,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
if (c) {
/* if modulus == 0:
raise ValueError() */
if (c->ob_size == 0) {
if (Py_Size(c) == 0) {
PyErr_SetString(PyExc_ValueError,
"pow() 3rd argument cannot be 0");
goto Error;
@ -2757,7 +2757,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
/* if modulus < 0:
negativeOutput = True
modulus = -modulus */
if (c->ob_size < 0) {
if (Py_Size(c) < 0) {
negativeOutput = 1;
temp = (PyLongObject *)_PyLong_Copy(c);
if (temp == NULL)
@ -2770,7 +2770,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
/* if modulus == 1:
return 0 */
if ((c->ob_size == 1) && (c->ob_digit[0] == 1)) {
if ((Py_Size(c) == 1) && (c->ob_digit[0] == 1)) {
z = (PyLongObject *)PyLong_FromLong(0L);
goto Done;
}
@ -2778,7 +2778,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
/* if base < 0:
base = base % modulus
Having the base positive just makes things easier. */
if (a->ob_size < 0) {
if (Py_Size(a) < 0) {
if (l_divmod(a, c, NULL, &temp) < 0)
goto Error;
Py_DECREF(a);
@ -2819,10 +2819,10 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
REDUCE(result) \
}
if (b->ob_size <= FIVEARY_CUTOFF) {
if (Py_Size(b) <= FIVEARY_CUTOFF) {
/* Left-to-right binary exponentiation (HAC Algorithm 14.79) */
/* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf */
for (i = b->ob_size - 1; i >= 0; --i) {
for (i = Py_Size(b) - 1; i >= 0; --i) {
digit bi = b->ob_digit[i];
for (j = 1 << (SHIFT-1); j != 0; j >>= 1) {
@ -2839,7 +2839,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
for (i = 1; i < 32; ++i)
MULT(table[i-1], a, table[i])
for (i = b->ob_size - 1; i >= 0; --i) {
for (i = Py_Size(b) - 1; i >= 0; --i) {
const digit bi = b->ob_digit[i];
for (j = SHIFT - 5; j >= 0; j -= 5) {
@ -2852,7 +2852,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
}
}
if (negativeOutput && (z->ob_size != 0)) {
if (negativeOutput && (Py_Size(z) != 0)) {
temp = (PyLongObject *)long_sub(z, c);
if (temp == NULL)
goto Error;
@ -2869,7 +2869,7 @@ long_pow(PyObject *v, PyObject *w, PyObject *x)
}
/* fall through */
Done:
if (b->ob_size > FIVEARY_CUTOFF) {
if (Py_Size(b) > FIVEARY_CUTOFF) {
for (i = 0; i < 32; ++i)
Py_XDECREF(table[i]);
}
@ -2893,7 +2893,7 @@ long_invert(PyLongObject *v)
Py_DECREF(w);
if (x == NULL)
return NULL;
x->ob_size = -(x->ob_size);
Py_Size(x) = -(Py_Size(x));
return (PyObject *)x;
}
@ -2935,7 +2935,7 @@ long_abs(PyLongObject *v)
static int
long_nonzero(PyLongObject *v)
{
return ABS(v->ob_size) != 0;
return ABS(Py_Size(v)) != 0;
}
static PyObject *
@ -2949,7 +2949,7 @@ long_rshift(PyLongObject *v, PyLongObject *w)
CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b);
if (a->ob_size < 0) {
if (Py_Size(a) < 0) {
/* Right shifting negative numbers is harder */
PyLongObject *a1, *a2;
a1 = (PyLongObject *) long_invert(a);
@ -2973,7 +2973,7 @@ long_rshift(PyLongObject *v, PyLongObject *w)
goto rshift_error;
}
wordshift = shiftby / SHIFT;
newsize = ABS(a->ob_size) - wordshift;
newsize = ABS(Py_Size(a)) - wordshift;
if (newsize <= 0) {
z = _PyLong_New(0);
Py_DECREF(a);
@ -2987,8 +2987,8 @@ long_rshift(PyLongObject *v, PyLongObject *w)
z = _PyLong_New(newsize);
if (z == NULL)
goto rshift_error;
if (a->ob_size < 0)
z->ob_size = -(z->ob_size);
if (Py_Size(a) < 0)
Py_Size(z) = -(Py_Size(z));
for (i = 0, j = wordshift; i < newsize; i++, j++) {
z->ob_digit[i] = (a->ob_digit[j] >> loshift) & lomask;
if (i+1 < newsize)
@ -3076,7 +3076,7 @@ long_bitwise(PyLongObject *a,
digit diga, digb;
PyObject *v;
if (a->ob_size < 0) {
if (Py_Size(a) < 0) {
a = (PyLongObject *) long_invert(a);
if (a == NULL)
return NULL;
@ -3086,7 +3086,7 @@ long_bitwise(PyLongObject *a,
Py_INCREF(a);
maska = 0;
}
if (b->ob_size < 0) {
if (Py_Size(b) < 0) {
b = (PyLongObject *) long_invert(b);
if (b == NULL) {
Py_DECREF(a);
@ -3135,8 +3135,8 @@ long_bitwise(PyLongObject *a,
whose length should be ignored.
*/
size_a = a->ob_size;
size_b = b->ob_size;
size_a = Py_Size(a);
size_b = Py_Size(b);
size_z = op == '&'
? (maska
? size_b
@ -3343,7 +3343,7 @@ long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
if (tmp == NULL)
return NULL;
assert(PyLong_CheckExact(tmp));
n = tmp->ob_size;
n = Py_Size(tmp);
if (n < 0)
n = -n;
newobj = (PyLongObject *)type->tp_alloc(type, n);
@ -3352,7 +3352,7 @@ long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
return NULL;
}
assert(PyLong_Check(newobj));
newobj->ob_size = tmp->ob_size;
Py_Size(newobj) = Py_Size(tmp);
for (i = 0; i < n; i++)
newobj->ob_digit[i] = tmp->ob_digit[i];
Py_DECREF(tmp);

3
Objects/methodobject.c
View file

@ -231,8 +231,7 @@ meth_hash(PyCFunctionObject *a)
PyTypeObject PyCFunction_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"builtin_function_or_method",
sizeof(PyCFunctionObject),
0,

5
Objects/moduleobject.c
View file

@ -176,7 +176,7 @@ module_dealloc(PyModuleObject *m)
_PyModule_Clear((PyObject *)m);
Py_DECREF(m->md_dict);
}
m->ob_type->tp_free((PyObject *)m);
Py_Type(m)->tp_free((PyObject *)m);
}
static PyObject *
@ -215,8 +215,7 @@ Create a module object.\n\
The name must be a string; the optional doc argument can have any type.");
PyTypeObject PyModule_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"module", /* tp_name */
sizeof(PyModuleObject), /* tp_size */
0, /* tp_itemsize */

80
Objects/object.c
View file

@ -214,7 +214,7 @@ PyObject_Init(PyObject *op, PyTypeObject *tp)
if (op == NULL)
return PyErr_NoMemory();
/* Any changes should be reflected in PyObject_INIT (objimpl.h) */
op->ob_type = tp;
Py_Type(op) = tp;
_Py_NewReference(op);
return op;
}
@ -226,7 +226,7 @@ PyObject_InitVar(PyVarObject *op, PyTypeObject *tp, Py_ssize_t size)
return (PyVarObject *) PyErr_NoMemory();
/* Any changes should be reflected in PyObject_INIT_VAR */
op->ob_size = size;
op->ob_type = tp;
Py_Type(op) = tp;
_Py_NewReference((PyObject *)op);
return op;
}
@ -287,7 +287,7 @@ internal_print(PyObject *op, FILE *fp, int flags, int nesting)
universally available */
fprintf(fp, "<refcnt %ld at %p>",
(long)op->ob_refcnt, op);
else if (op->ob_type->tp_print == NULL) {
else if (Py_Type(op)->tp_print == NULL) {
PyObject *s;
if (flags & Py_PRINT_RAW)
s = PyObject_Str(op);
@ -302,7 +302,7 @@ internal_print(PyObject *op, FILE *fp, int flags, int nesting)
Py_XDECREF(s);
}
else
ret = (*op->ob_type->tp_print)(op, fp, flags);
ret = (*Py_Type(op)->tp_print)(op, fp, flags);
}
if (ret == 0) {
if (ferror(fp)) {
@ -335,7 +335,7 @@ void _PyObject_Dump(PyObject* op)
"type : %s\n"
"refcount: %ld\n"
"address : %p\n",
op->ob_type==NULL ? "NULL" : op->ob_type->tp_name,
Py_Type(op)==NULL ? "NULL" : Py_Type(op)->tp_name,
(long)op->ob_refcnt,
op);
}
@ -354,12 +354,12 @@ PyObject_Repr(PyObject *v)
#endif
if (v == NULL)
return PyString_FromString("<NULL>");
else if (v->ob_type->tp_repr == NULL)
else if (Py_Type(v)->tp_repr == NULL)
return PyString_FromFormat("<%s object at %p>",
v->ob_type->tp_name, v);
Py_Type(v)->tp_name, v);
else {
PyObject *res;
res = (*v->ob_type->tp_repr)(v);
res = (*Py_Type(v)->tp_repr)(v);
if (res == NULL)
return NULL;
#ifdef Py_USING_UNICODE
@ -376,7 +376,7 @@ PyObject_Repr(PyObject *v)
if (!PyString_Check(res)) {
PyErr_Format(PyExc_TypeError,
"__repr__ returned non-string (type %.200s)",
res->ob_type->tp_name);
Py_Type(res)->tp_name);
Py_DECREF(res);
return NULL;
}
@ -401,10 +401,10 @@ _PyObject_Str(PyObject *v)
return v;
}
#endif
if (v->ob_type->tp_str == NULL)
if (Py_Type(v)->tp_str == NULL)
return PyObject_Repr(v);
res = (*v->ob_type->tp_str)(v);
res = (*Py_Type(v)->tp_str)(v);
if (res == NULL)
return NULL;
type_ok = PyString_Check(res);
@ -414,7 +414,7 @@ _PyObject_Str(PyObject *v)
if (!type_ok) {
PyErr_Format(PyExc_TypeError,
"__str__ returned non-string (type %.200s)",
res->ob_type->tp_name);
Py_Type(res)->tp_name);
Py_DECREF(res);
return NULL;
}
@ -488,8 +488,8 @@ PyObject_Unicode(PyObject *v)
res = v;
}
else {
if (v->ob_type->tp_str != NULL)
res = (*v->ob_type->tp_str)(v);
if (Py_Type(v)->tp_str != NULL)
res = (*Py_Type(v)->tp_str)(v);
else
res = PyObject_Repr(v);
}
@ -1062,8 +1062,8 @@ PyObject_GetAttrString(PyObject *v, const char *name)
{
PyObject *w, *res;
if (v->ob_type->tp_getattr != NULL)
return (*v->ob_type->tp_getattr)(v, (char*)name);
if (Py_Type(v)->tp_getattr != NULL)
return (*Py_Type(v)->tp_getattr)(v, (char*)name);
w = PyString_InternFromString(name);
if (w == NULL)
return NULL;
@ -1090,8 +1090,8 @@ PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
PyObject *s;
int res;
if (v->ob_type->tp_setattr != NULL)
return (*v->ob_type->tp_setattr)(v, (char*)name, w);
if (Py_Type(v)->tp_setattr != NULL)
return (*Py_Type(v)->tp_setattr)(v, (char*)name, w);
s = PyString_InternFromString(name);
if (s == NULL)
return -1;
@ -1103,7 +1103,7 @@ PyObject_SetAttrString(PyObject *v, const char *name, PyObject *w)
PyObject *
PyObject_GetAttr(PyObject *v, PyObject *name)
{
PyTypeObject *tp = v->ob_type;
PyTypeObject *tp = Py_Type(v);
if (!PyString_Check(name)) {
#ifdef Py_USING_UNICODE
@ -1120,7 +1120,7 @@ PyObject_GetAttr(PyObject *v, PyObject *name)
{
PyErr_Format(PyExc_TypeError,
"attribute name must be string, not '%.200s'",
name->ob_type->tp_name);
Py_Type(name)->tp_name);
return NULL;
}
}
@ -1149,7 +1149,7 @@ PyObject_HasAttr(PyObject *v, PyObject *name)
int
PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
{
PyTypeObject *tp = v->ob_type;
PyTypeObject *tp = Py_Type(v);
int err;
if (!PyString_Check(name)){
@ -1167,7 +1167,7 @@ PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
{
PyErr_Format(PyExc_TypeError,
"attribute name must be string, not '%.200s'",
name->ob_type->tp_name);
Py_Type(name)->tp_name);
return -1;
}
}
@ -1209,7 +1209,7 @@ PyObject **
_PyObject_GetDictPtr(PyObject *obj)
{
Py_ssize_t dictoffset;
PyTypeObject *tp = obj->ob_type;
PyTypeObject *tp = Py_Type(obj);
if (!(tp->tp_flags & Py_TPFLAGS_HAVE_CLASS))
return NULL;
@ -1244,7 +1244,7 @@ PyObject_SelfIter(PyObject *obj)
PyObject *
PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
{
PyTypeObject *tp = obj->ob_type;
PyTypeObject *tp = Py_Type(obj);
PyObject *descr = NULL;
PyObject *res = NULL;
descrgetfunc f;
@ -1266,7 +1266,7 @@ PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
{
PyErr_Format(PyExc_TypeError,
"attribute name must be string, not '%.200s'",
name->ob_type->tp_name);
Py_Type(name)->tp_name);
return NULL;
}
}
@ -1346,7 +1346,7 @@ PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
}
if (f != NULL) {
res = f(descr, obj, (PyObject *)obj->ob_type);
res = f(descr, obj, (PyObject *)Py_Type(obj));
Py_DECREF(descr);
goto done;
}
@ -1368,7 +1368,7 @@ PyObject_GenericGetAttr(PyObject *obj, PyObject *name)
int
PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
{
PyTypeObject *tp = obj->ob_type;
PyTypeObject *tp = Py_Type(obj);
PyObject *descr;
descrsetfunc f;
PyObject **dictptr;
@ -1389,7 +1389,7 @@ PyObject_GenericSetAttr(PyObject *obj, PyObject *name, PyObject *value)
{
PyErr_Format(PyExc_TypeError,
"attribute name must be string, not '%.200s'",
name->ob_type->tp_name);
Py_Type(name)->tp_name);
return -1;
}
}
@ -1683,7 +1683,7 @@ _dir_locals(void)
if (!PyList_Check(names)) {
PyErr_Format(PyExc_TypeError,
"dir(): expected keys() of locals to be a list, "
"not '%.200s'", names->ob_type->tp_name);
"not '%.200s'", Py_Type(names)->tp_name);
Py_DECREF(names);
return NULL;
}
@ -1818,7 +1818,7 @@ _dir_object(PyObject *obj)
if (!PyList_Check(result)) {
PyErr_Format(PyExc_TypeError,
"__dir__() must return a list, not %.200s",
result->ob_type->tp_name);
Py_Type(result)->tp_name);
Py_DECREF(result);
result = NULL;
}
@ -1880,8 +1880,7 @@ none_dealloc(PyObject* ignore)
static PyTypeObject PyNone_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"NoneType",
0,
0,
@ -1898,7 +1897,8 @@ static PyTypeObject PyNone_Type = {
};
PyObject _Py_NoneStruct = {
PyObject_HEAD_INIT(&PyNone_Type)
_PyObject_EXTRA_INIT
1, &PyNone_Type
};
/* NotImplemented is an object that can be used to signal that an
@ -1911,8 +1911,7 @@ NotImplemented_repr(PyObject *op)
}
static PyTypeObject PyNotImplemented_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"NotImplementedType",
0,
0,
@ -1929,7 +1928,8 @@ static PyTypeObject PyNotImplemented_Type = {
};
PyObject _Py_NotImplementedStruct = {
PyObject_HEAD_INIT(&PyNotImplemented_Type)
_PyObject_EXTRA_INIT
1, &PyNotImplemented_Type
};
void
@ -1997,7 +1997,7 @@ _Py_ForgetReference(register PyObject *op)
void
_Py_Dealloc(PyObject *op)
{
destructor dealloc = op->ob_type->tp_dealloc;
destructor dealloc = Py_Type(op)->tp_dealloc;
_Py_ForgetReference(op);
(*dealloc)(op);
}
@ -2028,7 +2028,7 @@ _Py_PrintReferenceAddresses(FILE *fp)
fprintf(fp, "Remaining object addresses:\n");
for (op = refchain._ob_next; op != &refchain; op = op->_ob_next)
fprintf(fp, "%p [%" PY_FORMAT_SIZE_T "d] %s\n", op,
op->ob_refcnt, op->ob_type->tp_name);
op->ob_refcnt, Py_Type(op)->tp_name);
}
PyObject *
@ -2046,7 +2046,7 @@ _Py_GetObjects(PyObject *self, PyObject *args)
return NULL;
for (i = 0; (n == 0 || i < n) && op != &refchain; i++) {
while (op == self || op == args || op == res || op == t ||
(t != NULL && op->ob_type != (PyTypeObject *) t)) {
(t != NULL && Py_Type(op) != (PyTypeObject *) t)) {
op = op->_ob_next;
if (op == &refchain)
return res;
@ -2189,7 +2189,7 @@ _PyTrash_destroy_chain(void)
{
while (_PyTrash_delete_later) {
PyObject *op = _PyTrash_delete_later;
destructor dealloc = op->ob_type->tp_dealloc;
destructor dealloc = Py_Type(op)->tp_dealloc;
_PyTrash_delete_later =
(PyObject*) _Py_AS_GC(op)->gc.gc_prev;

2
Objects/obmalloc.c
View file

@ -675,8 +675,8 @@ extremely desirable that it be this fast.
/* This is only useful when running memory debuggers such as
* Purify or Valgrind. Uncomment to use.
*
#define Py_USING_MEMORY_DEBUGGER
*/
#define Py_USING_MEMORY_DEBUGGER
#ifdef Py_USING_MEMORY_DEBUGGER

43
Objects/setobject.c
View file

@ -3,7 +3,7 @@
Written and maintained by Raymond D. Hettinger <python@rcn.com>
Derived from Lib/sets.py and Objects/dictobject.c.
Copyright (c) 2003-6 Python Software Foundation.
Copyright (c) 2003-2007 Python Software Foundation.
All rights reserved.
*/
@ -561,7 +561,7 @@ set_dealloc(PySetObject *so)
if (num_free_sets < MAXFREESETS && PyAnySet_CheckExact(so))
free_sets[num_free_sets++] = so;
else
so->ob_type->tp_free(so);
Py_Type(so)->tp_free(so);
Py_TRASHCAN_SAFE_END(so)
}
@ -860,8 +860,7 @@ fail:
}
static PyTypeObject PySetIter_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"setiterator", /* tp_name */
sizeof(setiterobject), /* tp_basicsize */
0, /* tp_itemsize */
@ -987,7 +986,7 @@ make_new_set(PyTypeObject *type, PyObject *iterable)
(type == &PySet_Type || type == &PyFrozenSet_Type)) {
so = free_sets[--num_free_sets];
assert (so != NULL && PyAnySet_CheckExact(so));
so->ob_type = type;
Py_Type(so) = type;
_Py_NewReference((PyObject *)so);
EMPTY_TO_MINSIZE(so);
PyObject_GC_Track(so);
@ -1113,8 +1112,8 @@ set_swap_bodies(PySetObject *a, PySetObject *b)
memcpy(b->smalltable, tab, sizeof(tab));
}
if (PyType_IsSubtype(a->ob_type, &PyFrozenSet_Type) &&
PyType_IsSubtype(b->ob_type, &PyFrozenSet_Type)) {
if (PyType_IsSubtype(Py_Type(a), &PyFrozenSet_Type) &&
PyType_IsSubtype(Py_Type(b), &PyFrozenSet_Type)) {
h = a->hash; a->hash = b->hash; b->hash = h;
} else {
a->hash = -1;
@ -1125,7 +1124,7 @@ set_swap_bodies(PySetObject *a, PySetObject *b)
static PyObject *
set_copy(PySetObject *so)
{
return make_new_set(so->ob_type, (PyObject *)so);
return make_new_set(Py_Type(so), (PyObject *)so);
}
static PyObject *
@ -1203,7 +1202,7 @@ set_intersection(PySetObject *so, PyObject *other)
if ((PyObject *)so == other)
return set_copy(so);
result = (PySetObject *)make_new_set(so->ob_type, NULL);
result = (PySetObject *)make_new_set(Py_Type(so), NULL);
if (result == NULL)
return NULL;
@ -1390,7 +1389,7 @@ set_difference(PySetObject *so, PyObject *other)
return NULL;
}
result = make_new_set(so->ob_type, NULL);
result = make_new_set(Py_Type(so), NULL);
if (result == NULL)
return NULL;
@ -1491,7 +1490,7 @@ set_symmetric_difference_update(PySetObject *so, PyObject *other)
Py_INCREF(other);
otherset = (PySetObject *)other;
} else {
otherset = (PySetObject *)make_new_set(so->ob_type, other);
otherset = (PySetObject *)make_new_set(Py_Type(so), other);
if (otherset == NULL)
return NULL;
}
@ -1522,7 +1521,7 @@ set_symmetric_difference(PySetObject *so, PyObject *other)
PyObject *rv;
PySetObject *otherset;
otherset = (PySetObject *)make_new_set(so->ob_type, other);
otherset = (PySetObject *)make_new_set(Py_Type(so), other);
if (otherset == NULL)
return NULL;
rv = set_symmetric_difference_update(otherset, (PyObject *)so);
@ -1789,7 +1788,7 @@ set_reduce(PySetObject *so)
dict = Py_None;
Py_INCREF(dict);
}
result = PyTuple_Pack(3, so->ob_type, args, dict);
result = PyTuple_Pack(3, Py_Type(so), args, dict);
done:
Py_XDECREF(args);
Py_XDECREF(keys);
@ -1806,7 +1805,7 @@ set_init(PySetObject *self, PyObject *args, PyObject *kwds)
if (!PyAnySet_Check(self))
return -1;
if (!PyArg_UnpackTuple(args, self->ob_type->tp_name, 0, 1, &iterable))
if (!PyArg_UnpackTuple(args, Py_Type(self)->tp_name, 0, 1, &iterable))
return -1;
set_clear_internal(self);
self->hash = -1;
@ -1922,8 +1921,7 @@ PyDoc_STRVAR(set_doc,
Build an unordered collection of unique elements.");
PyTypeObject PySet_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"set", /* tp_name */
sizeof(PySetObject), /* tp_basicsize */
0, /* tp_itemsize */
@ -2017,8 +2015,7 @@ PyDoc_STRVAR(frozenset_doc,
Build an immutable unordered collection of unique elements.");
PyTypeObject PyFrozenSet_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"frozenset", /* tp_name */
sizeof(PySetObject), /* tp_basicsize */
0, /* tp_itemsize */
@ -2099,7 +2096,7 @@ PySet_Size(PyObject *anyset)
int
PySet_Clear(PyObject *set)
{
if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
PyErr_BadInternalCall();
return -1;
}
@ -2119,7 +2116,7 @@ PySet_Contains(PyObject *anyset, PyObject *key)
int
PySet_Discard(PyObject *set, PyObject *key)
{
if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
PyErr_BadInternalCall();
return -1;
}
@ -2129,7 +2126,7 @@ PySet_Discard(PyObject *set, PyObject *key)
int
PySet_Add(PyObject *set, PyObject *key)
{
if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
PyErr_BadInternalCall();
return -1;
}
@ -2170,7 +2167,7 @@ _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, long *hash)
PyObject *
PySet_Pop(PyObject *set)
{
if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
PyErr_BadInternalCall();
return NULL;
}
@ -2180,7 +2177,7 @@ PySet_Pop(PyObject *set)
int
_PySet_Update(PyObject *set, PyObject *iterable)
{
if (!PyType_IsSubtype(set->ob_type, &PySet_Type)) {
if (!PyType_IsSubtype(Py_Type(set), &PySet_Type)) {
PyErr_BadInternalCall();
return -1;
}

11
Objects/sliceobject.c
View file

@ -23,8 +23,7 @@ ellipsis_repr(PyObject *op)
}
static PyTypeObject PyEllipsis_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"ellipsis", /* tp_name */
0, /* tp_basicsize */
0, /* tp_itemsize */
@ -47,7 +46,8 @@ static PyTypeObject PyEllipsis_Type = {
};
PyObject _Py_EllipsisObject = {
PyObject_HEAD_INIT(&PyEllipsis_Type)
_PyObject_EXTRA_INIT
1, &PyEllipsis_Type
};
@ -277,7 +277,7 @@ handling of normal slices.");
static PyObject *
slice_reduce(PySliceObject* self)
{
return Py_BuildValue("O(OOO)", self->ob_type, self->start, self->stop, self->step);
return Py_BuildValue("O(OOO)", Py_Type(self), self->start, self->stop, self->step);
}
PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
@ -319,8 +319,7 @@ slice_hash(PySliceObject *v)
}
PyTypeObject PySlice_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* Number of items for varobject */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"slice", /* Name of this type */
sizeof(PySliceObject), /* Basic object size */
0, /* Item size for varobject */

134
Objects/stringobject.c
View file

@ -421,7 +421,7 @@ PyObject *PyString_AsDecodedString(PyObject *str,
if (!PyString_Check(v)) {
PyErr_Format(PyExc_TypeError,
"decoder did not return a string object (type=%.400s)",
v->ob_type->tp_name);
Py_Type(v)->tp_name);
Py_DECREF(v);
goto onError;
}
@ -501,7 +501,7 @@ PyObject *PyString_AsEncodedString(PyObject *str,
if (!PyString_Check(v)) {
PyErr_Format(PyExc_TypeError,
"encoder did not return a string object (type=%.400s)",
v->ob_type->tp_name);
Py_Type(v)->tp_name);
Py_DECREF(v);
goto onError;
}
@ -521,7 +521,7 @@ string_dealloc(PyObject *op)
case SSTATE_INTERNED_MORTAL:
/* revive dead object temporarily for DelItem */
op->ob_refcnt = 3;
Py_Refcnt(op) = 3;
if (PyDict_DelItem(interned, op) != 0)
Py_FatalError(
"deletion of interned string failed");
@ -533,7 +533,7 @@ string_dealloc(PyObject *op)
default:
Py_FatalError("Inconsistent interned string state.");
}
op->ob_type->tp_free(op);
Py_Type(op)->tp_free(op);
}
/* Unescape a backslash-escaped string. If unicode is non-zero,
@ -717,7 +717,7 @@ PyString_Size(register PyObject *op)
{
if (!PyString_Check(op))
return string_getsize(op);
return ((PyStringObject *)op) -> ob_size;
return Py_Size(op);
}
/*const*/ char *
@ -750,7 +750,7 @@ PyString_AsStringAndSize(register PyObject *obj,
{
PyErr_Format(PyExc_TypeError,
"expected string or Unicode object, "
"%.200s found", obj->ob_type->tp_name);
"%.200s found", Py_Type(obj)->tp_name);
return -1;
}
}
@ -805,7 +805,7 @@ string_print(PyStringObject *op, FILE *fp, int flags)
}
if (flags & Py_PRINT_RAW) {
char *data = op->ob_sval;
Py_ssize_t size = op->ob_size;
Py_ssize_t size = Py_Size(op);
while (size > INT_MAX) {
/* Very long strings cannot be written atomically.
* But don't write exactly INT_MAX bytes at a time
@ -826,12 +826,12 @@ string_print(PyStringObject *op, FILE *fp, int flags)
/* figure out which quote to use; single is preferred */
quote = '\'';
if (memchr(op->ob_sval, '\'', op->ob_size) &&
!memchr(op->ob_sval, '"', op->ob_size))
if (memchr(op->ob_sval, '\'', Py_Size(op)) &&
!memchr(op->ob_sval, '"', Py_Size(op)))
quote = '"';
fputc(quote, fp);
for (i = 0; i < op->ob_size; i++) {
for (i = 0; i < Py_Size(op); i++) {
c = op->ob_sval[i];
if (c == quote || c == '\\')
fprintf(fp, "\\%c", c);
@ -854,9 +854,9 @@ PyObject *
PyString_Repr(PyObject *obj, int smartquotes)
{
register PyStringObject* op = (PyStringObject*) obj;
size_t newsize = 2 + 4 * op->ob_size;
size_t newsize = 2 + 4 * Py_Size(op);
PyObject *v;
if (newsize > PY_SSIZE_T_MAX || newsize / 4 != op->ob_size) {
if (newsize > PY_SSIZE_T_MAX || newsize / 4 != Py_Size(op)) {
PyErr_SetString(PyExc_OverflowError,
"string is too large to make repr");
}
@ -873,13 +873,13 @@ PyString_Repr(PyObject *obj, int smartquotes)
/* figure out which quote to use; single is preferred */
quote = '\'';
if (smartquotes &&
memchr(op->ob_sval, '\'', op->ob_size) &&
!memchr(op->ob_sval, '"', op->ob_size))
memchr(op->ob_sval, '\'', Py_Size(op)) &&
!memchr(op->ob_sval, '"', Py_Size(op)))
quote = '"';
p = PyString_AS_STRING(v);
*p++ = quote;
for (i = 0; i < op->ob_size; i++) {
for (i = 0; i < Py_Size(op); i++) {
/* There's at least enough room for a hex escape
and a closing quote. */
assert(newsize - (p - PyString_AS_STRING(v)) >= 5);
@ -928,14 +928,14 @@ string_str(PyObject *s)
else {
/* Subtype -- return genuine string with the same value. */
PyStringObject *t = (PyStringObject *) s;
return PyString_FromStringAndSize(t->ob_sval, t->ob_size);
return PyString_FromStringAndSize(t->ob_sval, Py_Size(t));
}
}
static Py_ssize_t
string_length(PyStringObject *a)
{
return a->ob_size;
return Py_Size(a);
}
static PyObject *
@ -950,21 +950,21 @@ string_concat(register PyStringObject *a, register PyObject *bb)
#endif
PyErr_Format(PyExc_TypeError,
"cannot concatenate 'str' and '%.200s' objects",
bb->ob_type->tp_name);
Py_Type(bb)->tp_name);
return NULL;
}
#define b ((PyStringObject *)bb)
/* Optimize cases with empty left or right operand */
if ((a->ob_size == 0 || b->ob_size == 0) &&
if ((Py_Size(a) == 0 || Py_Size(b) == 0) &&
PyString_CheckExact(a) && PyString_CheckExact(b)) {
if (a->ob_size == 0) {
if (Py_Size(a) == 0) {
Py_INCREF(bb);
return bb;
}
Py_INCREF(a);
return (PyObject *)a;
}
size = a->ob_size + b->ob_size;
size = Py_Size(a) + Py_Size(b);
if (size < 0) {
PyErr_SetString(PyExc_OverflowError,
"strings are too large to concat");
@ -978,8 +978,8 @@ string_concat(register PyStringObject *a, register PyObject *bb)
PyObject_INIT_VAR(op, &PyString_Type, size);
op->ob_shash = -1;
op->ob_sstate = SSTATE_NOT_INTERNED;
Py_MEMCPY(op->ob_sval, a->ob_sval, a->ob_size);
Py_MEMCPY(op->ob_sval + a->ob_size, b->ob_sval, b->ob_size);
Py_MEMCPY(op->ob_sval, a->ob_sval, Py_Size(a));
Py_MEMCPY(op->ob_sval + Py_Size(a), b->ob_sval, Py_Size(b));
op->ob_sval[size] = '\0';
return (PyObject *) op;
#undef b
@ -998,13 +998,13 @@ string_repeat(register PyStringObject *a, register Py_ssize_t n)
/* watch out for overflows: the size can overflow int,
* and the # of bytes needed can overflow size_t
*/
size = a->ob_size * n;
if (n && size / n != a->ob_size) {
size = Py_Size(a) * n;
if (n && size / n != Py_Size(a)) {
PyErr_SetString(PyExc_OverflowError,
"repeated string is too long");
return NULL;
}
if (size == a->ob_size && PyString_CheckExact(a)) {
if (size == Py_Size(a) && PyString_CheckExact(a)) {
Py_INCREF(a);
return (PyObject *)a;
}
@ -1022,14 +1022,14 @@ string_repeat(register PyStringObject *a, register Py_ssize_t n)
op->ob_shash = -1;
op->ob_sstate = SSTATE_NOT_INTERNED;
op->ob_sval[size] = '\0';
if (a->ob_size == 1 && n > 0) {
if (Py_Size(a) == 1 && n > 0) {
memset(op->ob_sval, a->ob_sval[0] , n);
return (PyObject *) op;
}
i = 0;
if (i < size) {
Py_MEMCPY(op->ob_sval, a->ob_sval, a->ob_size);
i = a->ob_size;
Py_MEMCPY(op->ob_sval, a->ob_sval, Py_Size(a));
i = Py_Size(a);
}
while (i < size) {
j = (i <= size-i) ? i : size-i;
@ -1050,9 +1050,9 @@ string_slice(register PyStringObject *a, register Py_ssize_t i,
i = 0;
if (j < 0)
j = 0; /* Avoid signed/unsigned bug in next line */
if (j > a->ob_size)
j = a->ob_size;
if (i == 0 && j == a->ob_size && PyString_CheckExact(a)) {
if (j > Py_Size(a))
j = Py_Size(a);
if (i == 0 && j == Py_Size(a) && PyString_CheckExact(a)) {
/* It's the same as a */
Py_INCREF(a);
return (PyObject *)a;
@ -1073,7 +1073,7 @@ string_contains(PyObject *str_obj, PyObject *sub_obj)
if (!PyString_Check(sub_obj)) {
PyErr_Format(PyExc_TypeError,
"'in <string>' requires string as left operand, "
"not %.200s", sub_obj->ob_type->tp_name);
"not %.200s", Py_Type(sub_obj)->tp_name);
return -1;
}
}
@ -1086,7 +1086,7 @@ string_item(PyStringObject *a, register Py_ssize_t i)
{
char pchar;
PyObject *v;
if (i < 0 || i >= a->ob_size) {
if (i < 0 || i >= Py_Size(a)) {
PyErr_SetString(PyExc_IndexError, "string index out of range");
return NULL;
}
@ -1129,16 +1129,16 @@ string_richcompare(PyStringObject *a, PyStringObject *b, int op)
if (op == Py_EQ) {
/* Supporting Py_NE here as well does not save
much time, since Py_NE is rarely used. */
if (a->ob_size == b->ob_size
if (Py_Size(a) == Py_Size(b)
&& (a->ob_sval[0] == b->ob_sval[0]
&& memcmp(a->ob_sval, b->ob_sval, a->ob_size) == 0)) {
&& memcmp(a->ob_sval, b->ob_sval, Py_Size(a)) == 0)) {
result = Py_True;
} else {
result = Py_False;
}
goto out;
}
len_a = a->ob_size; len_b = b->ob_size;
len_a = Py_Size(a); len_b = Py_Size(b);
min_len = (len_a < len_b) ? len_a : len_b;
if (min_len > 0) {
c = Py_CHARMASK(*a->ob_sval) - Py_CHARMASK(*b->ob_sval);
@ -1170,9 +1170,9 @@ _PyString_Eq(PyObject *o1, PyObject *o2)
{
PyStringObject *a = (PyStringObject*) o1;
PyStringObject *b = (PyStringObject*) o2;
return a->ob_size == b->ob_size
return Py_Size(a) == Py_Size(b)
&& *a->ob_sval == *b->ob_sval
&& memcmp(a->ob_sval, b->ob_sval, a->ob_size) == 0;
&& memcmp(a->ob_sval, b->ob_sval, Py_Size(a)) == 0;
}
static long
@ -1184,12 +1184,12 @@ string_hash(PyStringObject *a)
if (a->ob_shash != -1)
return a->ob_shash;
len = a->ob_size;
len = Py_Size(a);
p = (unsigned char *) a->ob_sval;
x = *p << 7;
while (--len >= 0)
x = (1000003*x) ^ *p++;
x ^= a->ob_size;
x ^= Py_Size(a);
if (x == -1)
x = -2;
a->ob_shash = x;
@ -1242,7 +1242,7 @@ string_subscript(PyStringObject* self, PyObject* item)
else {
PyErr_Format(PyExc_TypeError,
"string indices must be integers, not %.200s",
item->ob_type->tp_name);
Py_Type(item)->tp_name);
return NULL;
}
}
@ -1256,7 +1256,7 @@ string_buffer_getreadbuf(PyStringObject *self, Py_ssize_t index, const void **pt
return -1;
}
*ptr = (void *)self->ob_sval;
return self->ob_size;
return Py_Size(self);
}
static Py_ssize_t
@ -1271,7 +1271,7 @@ static Py_ssize_t
string_buffer_getsegcount(PyStringObject *self, Py_ssize_t *lenp)
{
if ( lenp )
*lenp = self->ob_size;
*lenp = Py_Size(self);
return 1;
}
@ -1284,7 +1284,7 @@ string_buffer_getcharbuf(PyStringObject *self, Py_ssize_t index, const char **pt
return -1;
}
*ptr = self->ob_sval;
return self->ob_size;
return Py_Size(self);
}
static PySequenceMethods string_as_sequence = {
@ -1373,7 +1373,7 @@ static const char *stripformat[] = {"|O:lstrip", "|O:rstrip", "|O:strip"};
count++; }
/* Always force the list to the expected size. */
#define FIX_PREALLOC_SIZE(list) ((PyListObject *)list)->ob_size = count
#define FIX_PREALLOC_SIZE(list) Py_Size(list) = count
#define SKIP_SPACE(s, i, len) { while (i<len && isspace(Py_CHARMASK(s[i]))) i++; }
#define SKIP_NONSPACE(s, i, len) { while (i<len && !isspace(Py_CHARMASK(s[i]))) i++; }
@ -1788,7 +1788,7 @@ string_join(PyStringObject *self, PyObject *orig)
PyErr_Format(PyExc_TypeError,
"sequence item %zd: expected string,"
" %.80s found",
i, item->ob_type->tp_name);
i, Py_Type(item)->tp_name);
Py_DECREF(seq);
return NULL;
}
@ -3248,7 +3248,7 @@ string_encode(PyStringObject *self, PyObject *args)
PyErr_Format(PyExc_TypeError,
"encoder did not return a string/unicode object "
"(type=%.400s)",
v->ob_type->tp_name);
Py_Type(v)->tp_name);
Py_DECREF(v);
return NULL;
}
@ -3285,7 +3285,7 @@ string_decode(PyStringObject *self, PyObject *args)
PyErr_Format(PyExc_TypeError,
"decoder did not return a string/unicode object "
"(type=%.400s)",
v->ob_type->tp_name);
Py_Type(v)->tp_name);
Py_DECREF(v);
return NULL;
}
@ -3843,7 +3843,7 @@ string_splitlines(PyStringObject *self, PyObject *args)
static PyObject *
string_getnewargs(PyStringObject *v)
{
return Py_BuildValue("(s#)", v->ob_sval, v->ob_size);
return Py_BuildValue("(s#)", v->ob_sval, Py_Size(v));
}
@ -3972,8 +3972,7 @@ static PyNumberMethods string_as_number = {
PyTypeObject PyBaseString_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"basestring",
0,
0,
@ -4021,8 +4020,7 @@ Return a nice string representation of the object.\n\
If the argument is a string, the return value is the same object.");
PyTypeObject PyString_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"str",
sizeof(PyStringObject),
sizeof(char),
@ -4108,7 +4106,7 @@ _PyString_Resize(PyObject **pv, Py_ssize_t newsize)
register PyObject *v;
register PyStringObject *sv;
v = *pv;
if (!PyString_Check(v) || v->ob_refcnt != 1 || newsize < 0 ||
if (!PyString_Check(v) || Py_Refcnt(v) != 1 || newsize < 0 ||
PyString_CHECK_INTERNED(v)) {
*pv = 0;
Py_DECREF(v);
@ -4127,7 +4125,7 @@ _PyString_Resize(PyObject **pv, Py_ssize_t newsize)
}
_Py_NewReference(*pv);
sv = (PyStringObject *) *pv;
sv->ob_size = newsize;
Py_Size(sv) = newsize;
sv->ob_sval[newsize] = '\0';
sv->ob_shash = -1; /* invalidate cached hash value */
return 0;
@ -4175,7 +4173,7 @@ formatfloat(char *buf, size_t buflen, int flags,
x = PyFloat_AsDouble(v);
if (x == -1.0 && PyErr_Occurred()) {
PyErr_Format(PyExc_TypeError, "float argument required, "
"not %.200s", v->ob_type->tp_name);
"not %.200s", Py_Type(v)->tp_name);
return -1;
}
if (prec < 0)
@ -4249,15 +4247,15 @@ _PyString_FormatLong(PyObject *val, int flags, int prec, int type,
switch (type) {
case 'd':
case 'u':
result = val->ob_type->tp_str(val);
result = Py_Type(val)->tp_str(val);
break;
case 'o':
result = val->ob_type->tp_as_number->nb_oct(val);
result = Py_Type(val)->tp_as_number->nb_oct(val);
break;
case 'x':
case 'X':
numnondigits = 2;
result = val->ob_type->tp_as_number->nb_hex(val);
result = Py_Type(val)->tp_as_number->nb_hex(val);
break;
default:
assert(!"'type' not in [duoxX]");
@ -4272,7 +4270,7 @@ _PyString_FormatLong(PyObject *val, int flags, int prec, int type,
}
/* To modify the string in-place, there can only be one reference. */
if (result->ob_refcnt != 1) {
if (Py_Refcnt(result) != 1) {
PyErr_BadInternalCall();
return NULL;
}
@ -4372,7 +4370,7 @@ formatint(char *buf, size_t buflen, int flags,
x = PyInt_AsLong(v);
if (x == -1 && PyErr_Occurred()) {
PyErr_Format(PyExc_TypeError, "int argument required, not %.200s",
v->ob_type->tp_name);
Py_Type(v)->tp_name);
return -1;
}
if (x < 0 && type == 'u') {
@ -4489,7 +4487,7 @@ PyString_Format(PyObject *format, PyObject *args)
arglen = -1;
argidx = -2;
}
if (args->ob_type->tp_as_mapping && !PyTuple_Check(args) &&
if (Py_Type(args)->tp_as_mapping && !PyTuple_Check(args) &&
!PyObject_TypeCheck(args, &PyBaseString_Type))
dict = args;
while (--fmtcnt >= 0) {
@ -4956,7 +4954,7 @@ PyString_InternInPlace(PyObject **p)
}
/* The two references in interned are not counted by refcnt.
The string deallocator will take care of this */
s->ob_refcnt -= 2;
Py_Refcnt(s) -= 2;
PyString_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
}
@ -5023,12 +5021,12 @@ void _Py_ReleaseInternedStrings(void)
/* XXX Shouldn't happen */
break;
case SSTATE_INTERNED_IMMORTAL:
s->ob_refcnt += 1;
immortal_size += s->ob_size;
Py_Refcnt(s) += 1;
immortal_size += Py_Size(s);
break;
case SSTATE_INTERNED_MORTAL:
s->ob_refcnt += 2;
mortal_size += s->ob_size;
Py_Refcnt(s) += 2;
mortal_size += Py_Size(s);
break;
default:
Py_FatalError("Inconsistent interned string state.");

15
Objects/structseq.c
View file

@ -13,17 +13,17 @@ static char unnamed_fields_key[] = "n_unnamed_fields";
They are only allowed for indices < n_visible_fields. */
char *PyStructSequence_UnnamedField = "unnamed field";
#define VISIBLE_SIZE(op) ((op)->ob_size)
#define VISIBLE_SIZE(op) Py_Size(op)
#define VISIBLE_SIZE_TP(tp) PyInt_AsLong( \
PyDict_GetItemString((tp)->tp_dict, visible_length_key))
#define REAL_SIZE_TP(tp) PyInt_AsLong( \
PyDict_GetItemString((tp)->tp_dict, real_length_key))
#define REAL_SIZE(op) REAL_SIZE_TP((op)->ob_type)
#define REAL_SIZE(op) REAL_SIZE_TP(Py_Type(op))
#define UNNAMED_FIELDS_TP(tp) PyInt_AsLong( \
PyDict_GetItemString((tp)->tp_dict, unnamed_fields_key))
#define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP((op)->ob_type)
#define UNNAMED_FIELDS(op) UNNAMED_FIELDS_TP(Py_Type(op))
PyObject *
@ -32,7 +32,7 @@ PyStructSequence_New(PyTypeObject *type)
PyStructSequence *obj;
obj = PyObject_New(PyStructSequence, type);
obj->ob_size = VISIBLE_SIZE_TP(type);
Py_Size(obj) = VISIBLE_SIZE_TP(type);
return (PyObject*) obj;
}
@ -274,12 +274,12 @@ structseq_reduce(PyStructSequence* self)
}
for (; i < n_fields; i++) {
char *n = self->ob_type->tp_members[i-n_unnamed_fields].name;
char *n = Py_Type(self)->tp_members[i-n_unnamed_fields].name;
PyDict_SetItemString(dict, n,
self->ob_item[i]);
}
result = Py_BuildValue("(O(OO))", self->ob_type, tup, dict);
result = Py_BuildValue("(O(OO))", Py_Type(self), tup, dict);
Py_DECREF(tup);
Py_DECREF(dict);
@ -305,8 +305,7 @@ static PyMethodDef structseq_methods[] = {
};
static PyTypeObject _struct_sequence_template = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
NULL, /* tp_name */
0, /* tp_basicsize */
0, /* tp_itemsize */

78
Objects/tupleobject.c
View file

@ -49,8 +49,8 @@ PyTuple_New(register Py_ssize_t size)
#endif
/* Inline PyObject_InitVar */
#ifdef Py_TRACE_REFS
op->ob_size = size;
op->ob_type = &PyTuple_Type;
Py_Size(op) = size;
Py_Type(op) = &PyTuple_Type;
#endif
_Py_NewReference((PyObject *)op);
}
@ -90,7 +90,7 @@ PyTuple_Size(register PyObject *op)
return -1;
}
else
return ((PyTupleObject *)op)->ob_size;
return Py_Size(op);
}
PyObject *
@ -100,7 +100,7 @@ PyTuple_GetItem(register PyObject *op, register Py_ssize_t i)
PyErr_BadInternalCall();
return NULL;
}
if (i < 0 || i >= ((PyTupleObject *)op) -> ob_size) {
if (i < 0 || i >= Py_Size(op)) {
PyErr_SetString(PyExc_IndexError, "tuple index out of range");
return NULL;
}
@ -117,7 +117,7 @@ PyTuple_SetItem(register PyObject *op, register Py_ssize_t i, PyObject *newitem)
PyErr_BadInternalCall();
return -1;
}
if (i < 0 || i >= ((PyTupleObject *)op) -> ob_size) {
if (i < 0 || i >= Py_Size(op)) {
Py_XDECREF(newitem);
PyErr_SetString(PyExc_IndexError,
"tuple assignment index out of range");
@ -160,7 +160,7 @@ static void
tupledealloc(register PyTupleObject *op)
{
register Py_ssize_t i;
register Py_ssize_t len = op->ob_size;
register Py_ssize_t len = Py_Size(op);
PyObject_GC_UnTrack(op);
Py_TRASHCAN_SAFE_BEGIN(op)
if (len > 0) {
@ -170,7 +170,7 @@ tupledealloc(register PyTupleObject *op)
#if MAXSAVESIZE > 0
if (len < MAXSAVESIZE &&
num_free_tuples[len] < MAXSAVEDTUPLES &&
op->ob_type == &PyTuple_Type)
Py_Type(op) == &PyTuple_Type)
{
op->ob_item[0] = (PyObject *) free_tuples[len];
num_free_tuples[len]++;
@ -179,7 +179,7 @@ tupledealloc(register PyTupleObject *op)
}
#endif
}
op->ob_type->tp_free((PyObject *)op);
Py_Type(op)->tp_free((PyObject *)op);
done:
Py_TRASHCAN_SAFE_END(op)
}
@ -189,13 +189,13 @@ tupleprint(PyTupleObject *op, FILE *fp, int flags)
{
Py_ssize_t i;
fprintf(fp, "(");
for (i = 0; i < op->ob_size; i++) {
for (i = 0; i < Py_Size(op); i++) {
if (i > 0)
fprintf(fp, ", ");
if (PyObject_Print(op->ob_item[i], fp, 0) != 0)
return -1;
}
if (op->ob_size == 1)
if (Py_Size(op) == 1)
fprintf(fp, ",");
fprintf(fp, ")");
return 0;
@ -208,7 +208,7 @@ tuplerepr(PyTupleObject *v)
PyObject *s, *temp;
PyObject *pieces, *result = NULL;
n = v->ob_size;
n = Py_Size(v);
if (n == 0)
return PyString_FromString("()");
@ -268,7 +268,7 @@ static long
tuplehash(PyTupleObject *v)
{
register long x, y;
register Py_ssize_t len = v->ob_size;
register Py_ssize_t len = Py_Size(v);
register PyObject **p;
long mult = 1000003L;
x = 0x345678L;
@ -290,7 +290,7 @@ tuplehash(PyTupleObject *v)
static Py_ssize_t
tuplelength(PyTupleObject *a)
{
return a->ob_size;
return Py_Size(a);
}
static int
@ -299,7 +299,7 @@ tuplecontains(PyTupleObject *a, PyObject *el)
Py_ssize_t i;
int cmp;
for (i = 0, cmp = 0 ; cmp == 0 && i < a->ob_size; ++i)
for (i = 0, cmp = 0 ; cmp == 0 && i < Py_Size(a); ++i)
cmp = PyObject_RichCompareBool(el, PyTuple_GET_ITEM(a, i),
Py_EQ);
return cmp;
@ -308,7 +308,7 @@ tuplecontains(PyTupleObject *a, PyObject *el)
static PyObject *
tupleitem(register PyTupleObject *a, register Py_ssize_t i)
{
if (i < 0 || i >= a->ob_size) {
if (i < 0 || i >= Py_Size(a)) {
PyErr_SetString(PyExc_IndexError, "tuple index out of range");
return NULL;
}
@ -326,11 +326,11 @@ tupleslice(register PyTupleObject *a, register Py_ssize_t ilow,
Py_ssize_t len;
if (ilow < 0)
ilow = 0;
if (ihigh > a->ob_size)
ihigh = a->ob_size;
if (ihigh > Py_Size(a))
ihigh = Py_Size(a);
if (ihigh < ilow)
ihigh = ilow;
if (ilow == 0 && ihigh == a->ob_size && PyTuple_CheckExact(a)) {
if (ilow == 0 && ihigh == Py_Size(a) && PyTuple_CheckExact(a)) {
Py_INCREF(a);
return (PyObject *)a;
}
@ -368,11 +368,11 @@ tupleconcat(register PyTupleObject *a, register PyObject *bb)
if (!PyTuple_Check(bb)) {
PyErr_Format(PyExc_TypeError,
"can only concatenate tuple (not \"%.200s\") to tuple",
bb->ob_type->tp_name);
Py_Type(bb)->tp_name);
return NULL;
}
#define b ((PyTupleObject *)bb)
size = a->ob_size + b->ob_size;
size = Py_Size(a) + Py_Size(b);
if (size < 0)
return PyErr_NoMemory();
np = (PyTupleObject *) PyTuple_New(size);
@ -381,14 +381,14 @@ tupleconcat(register PyTupleObject *a, register PyObject *bb)
}
src = a->ob_item;
dest = np->ob_item;
for (i = 0; i < a->ob_size; i++) {
for (i = 0; i < Py_Size(a); i++) {
PyObject *v = src[i];
Py_INCREF(v);
dest[i] = v;
}
src = b->ob_item;
dest = np->ob_item + a->ob_size;
for (i = 0; i < b->ob_size; i++) {
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;
@ -406,18 +406,18 @@ tuplerepeat(PyTupleObject *a, Py_ssize_t n)
PyObject **p, **items;
if (n < 0)
n = 0;
if (a->ob_size == 0 || n == 1) {
if (Py_Size(a) == 0 || n == 1) {
if (PyTuple_CheckExact(a)) {
/* Since tuples are immutable, we can return a shared
copy in this case */
Py_INCREF(a);
return (PyObject *)a;
}
if (a->ob_size == 0)
if (Py_Size(a) == 0)
return PyTuple_New(0);
}
size = a->ob_size * n;
if (size/a->ob_size != n)
size = Py_Size(a) * n;
if (size/Py_Size(a) != n)
return PyErr_NoMemory();
np = (PyTupleObject *) PyTuple_New(size);
if (np == NULL)
@ -425,7 +425,7 @@ tuplerepeat(PyTupleObject *a, Py_ssize_t n)
p = np->ob_item;
items = a->ob_item;
for (i = 0; i < n; i++) {
for (j = 0; j < a->ob_size; j++) {
for (j = 0; j < Py_Size(a); j++) {
*p = items[j];
Py_INCREF(*p);
p++;
@ -439,7 +439,7 @@ tupletraverse(PyTupleObject *o, visitproc visit, void *arg)
{
Py_ssize_t i;
for (i = o->ob_size; --i >= 0; )
for (i = Py_Size(o); --i >= 0; )
Py_VISIT(o->ob_item[i]);
return 0;
}
@ -459,8 +459,8 @@ tuplerichcompare(PyObject *v, PyObject *w, int op)
vt = (PyTupleObject *)v;
wt = (PyTupleObject *)w;
vlen = vt->ob_size;
wlen = wt->ob_size;
vlen = Py_Size(vt);
wlen = Py_Size(wt);
/* Note: the corresponding code for lists has an "early out" test
* here when op is EQ or NE and the lengths differ. That pays there,
@ -622,7 +622,7 @@ tuplesubscript(PyTupleObject* self, PyObject* item)
else {
PyErr_Format(PyExc_TypeError,
"tuple indices must be integers, not %.200s",
item->ob_type->tp_name);
Py_Type(item)->tp_name);
return NULL;
}
}
@ -630,7 +630,7 @@ tuplesubscript(PyTupleObject* self, PyObject* item)
static PyObject *
tuple_getnewargs(PyTupleObject *v)
{
return Py_BuildValue("(N)", tupleslice(v, 0, v->ob_size));
return Py_BuildValue("(N)", tupleslice(v, 0, Py_Size(v)));
}
@ -648,8 +648,7 @@ static PyMappingMethods tuple_as_mapping = {
static PyObject *tuple_iter(PyObject *seq);
PyTypeObject PyTuple_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"tuple",
sizeof(PyTupleObject) - sizeof(PyObject *),
sizeof(PyObject *),
@ -707,14 +706,14 @@ _PyTuple_Resize(PyObject **pv, Py_ssize_t newsize)
Py_ssize_t oldsize;
v = (PyTupleObject *) *pv;
if (v == NULL || v->ob_type != &PyTuple_Type ||
(v->ob_size != 0 && v->ob_refcnt != 1)) {
if (v == NULL || Py_Type(v) != &PyTuple_Type ||
(Py_Size(v) != 0 && Py_Refcnt(v) != 1)) {
*pv = 0;
Py_XDECREF(v);
PyErr_BadInternalCall();
return -1;
}
oldsize = v->ob_size;
oldsize = Py_Size(v);
if (oldsize == newsize)
return 0;
@ -838,8 +837,7 @@ static PyMethodDef tupleiter_methods[] = {
};
PyTypeObject PyTupleIter_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"tupleiterator", /* tp_name */
sizeof(tupleiterobject), /* tp_basicsize */
0, /* tp_itemsize */

189
Objects/typeobject.c
View file

@ -57,7 +57,7 @@ type_set_name(PyTypeObject *type, PyObject *value, void *context)
if (!PyString_Check(value)) {
PyErr_Format(PyExc_TypeError,
"can only assign string to %s.__name__, not '%s'",
type->tp_name, value->ob_type->tp_name);
type->tp_name, Py_Type(value)->tp_name);
return -1;
}
if (strlen(PyString_AS_STRING(value))
@ -203,7 +203,7 @@ type_set_bases(PyTypeObject *type, PyObject *value, void *context)
if (!PyTuple_Check(value)) {
PyErr_Format(PyExc_TypeError,
"can only assign tuple to %s.__bases__, not %s",
type->tp_name, value->ob_type->tp_name);
type->tp_name, Py_Type(value)->tp_name);
return -1;
}
if (PyTuple_GET_SIZE(value) == 0) {
@ -218,7 +218,7 @@ type_set_bases(PyTypeObject *type, PyObject *value, void *context)
PyErr_Format(
PyExc_TypeError,
"%s.__bases__ must be tuple of old- or new-style classes, not '%s'",
type->tp_name, ob->ob_type->tp_name);
type->tp_name, Py_Type(ob)->tp_name);
return -1;
}
if (PyType_Check(ob)) {
@ -343,8 +343,8 @@ type_get_doc(PyTypeObject *type, void *context)
result = Py_None;
Py_INCREF(result);
}
else if (result->ob_type->tp_descr_get) {
result = result->ob_type->tp_descr_get(result, NULL,
else if (Py_Type(result)->tp_descr_get) {
result = Py_Type(result)->tp_descr_get(result, NULL,
(PyObject *)type);
}
else {
@ -488,7 +488,7 @@ traverse_slots(PyTypeObject *type, PyObject *self, visitproc visit, void *arg)
Py_ssize_t i, n;
PyMemberDef *mp;
n = type->ob_size;
n = Py_Size(type);
mp = PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type);
for (i = 0; i < n; i++, mp++) {
if (mp->type == T_OBJECT_EX) {
@ -512,10 +512,10 @@ subtype_traverse(PyObject *self, visitproc visit, void *arg)
/* Find the nearest base with a different tp_traverse,
and traverse slots while we're at it */
type = self->ob_type;
type = Py_Type(self);
base = type;
while ((basetraverse = base->tp_traverse) == subtype_traverse) {
if (base->ob_size) {
if (Py_Size(base)) {
int err = traverse_slots(base, self, visit, arg);
if (err)
return err;
@ -547,7 +547,7 @@ clear_slots(PyTypeObject *type, PyObject *self)
Py_ssize_t i, n;
PyMemberDef *mp;
n = type->ob_size;
n = Py_Size(type);
mp = PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type);
for (i = 0; i < n; i++, mp++) {
if (mp->type == T_OBJECT_EX && !(mp->flags & READONLY)) {
@ -569,10 +569,10 @@ subtype_clear(PyObject *self)
/* Find the nearest base with a different tp_clear
and clear slots while we're at it */
type = self->ob_type;
type = Py_Type(self);
base = type;
while ((baseclear = base->tp_clear) == subtype_clear) {
if (base->ob_size)
if (Py_Size(base))
clear_slots(base, self);
base = base->tp_base;
assert(base);
@ -593,7 +593,7 @@ subtype_dealloc(PyObject *self)
destructor basedealloc;
/* Extract the type; we expect it to be a heap type */
type = self->ob_type;
type = Py_Type(self);
assert(type->tp_flags & Py_TPFLAGS_HEAPTYPE);
/* Test whether the type has GC exactly once */
@ -615,7 +615,7 @@ subtype_dealloc(PyObject *self)
/* Find the nearest base with a different tp_dealloc */
base = type;
while ((basedealloc = base->tp_dealloc) == subtype_dealloc) {
assert(base->ob_size == 0);
assert(Py_Size(base) == 0);
base = base->tp_base;
assert(base);
}
@ -683,7 +683,7 @@ subtype_dealloc(PyObject *self)
/* Clear slots up to the nearest base with a different tp_dealloc */
base = type;
while ((basedealloc = base->tp_dealloc) == subtype_dealloc) {
if (base->ob_size)
if (Py_Size(base))
clear_slots(base, self);
base = base->tp_base;
assert(base);
@ -877,13 +877,13 @@ lookup_maybe(PyObject *self, char *attrstr, PyObject **attrobj)
if (*attrobj == NULL)
return NULL;
}
res = _PyType_Lookup(self->ob_type, *attrobj);
res = _PyType_Lookup(Py_Type(self), *attrobj);
if (res != NULL) {
descrgetfunc f;
if ((f = res->ob_type->tp_descr_get) == NULL)
if ((f = Py_Type(res)->tp_descr_get) == NULL)
Py_INCREF(res);
else
res = f(res, self, (PyObject *)(self->ob_type));
res = f(res, self, (PyObject *)(Py_Type(self)));
}
return res;
}
@ -1301,7 +1301,7 @@ mro_internal(PyTypeObject *type)
PyObject *mro, *result, *tuple;
int checkit = 0;
if (type->ob_type == &PyType_Type) {
if (Py_Type(type) == &PyType_Type) {
result = mro_implementation(type);
}
else {
@ -1336,7 +1336,7 @@ mro_internal(PyTypeObject *type)
else if (!PyType_Check(cls)) {
PyErr_Format(PyExc_TypeError,
"mro() returned a non-class ('%.500s')",
cls->ob_type->tp_name);
Py_Type(cls)->tp_name);
Py_DECREF(tuple);
return -1;
}
@ -1565,7 +1565,7 @@ subtype_setdict(PyObject *obj, PyObject *value, void *context)
if (value != NULL && !PyDict_Check(value)) {
PyErr_Format(PyExc_TypeError,
"__dict__ must be set to a dictionary, "
"not a '%.200s'", value->ob_type->tp_name);
"not a '%.200s'", Py_Type(value)->tp_name);
return -1;
}
dict = *dictptr;
@ -1581,16 +1581,16 @@ subtype_getweakref(PyObject *obj, void *context)
PyObject **weaklistptr;
PyObject *result;
if (obj->ob_type->tp_weaklistoffset == 0) {
if (Py_Type(obj)->tp_weaklistoffset == 0) {
PyErr_SetString(PyExc_AttributeError,
"This object has no __weakref__");
return NULL;
}
assert(obj->ob_type->tp_weaklistoffset > 0);
assert(obj->ob_type->tp_weaklistoffset + sizeof(PyObject *) <=
(size_t)(obj->ob_type->tp_basicsize));
assert(Py_Type(obj)->tp_weaklistoffset > 0);
assert(Py_Type(obj)->tp_weaklistoffset + sizeof(PyObject *) <=
(size_t)(Py_Type(obj)->tp_basicsize));
weaklistptr = (PyObject **)
((char *)obj + obj->ob_type->tp_weaklistoffset);
((char *)obj + Py_Type(obj)->tp_weaklistoffset);
if (*weaklistptr == NULL)
result = Py_None;
else
@ -1630,7 +1630,7 @@ valid_identifier(PyObject *s)
if (!PyString_Check(s)) {
PyErr_Format(PyExc_TypeError,
"__slots__ items must be strings, not '%.200s'",
s->ob_type->tp_name);
Py_Type(s)->tp_name);
return 0;
}
p = (unsigned char *) PyString_AS_STRING(s);
@ -1740,8 +1740,8 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
if (PyType_CheckExact(metatype) && nargs == 1 && nkwds == 0) {
PyObject *x = PyTuple_GET_ITEM(args, 0);
Py_INCREF(x->ob_type);
return (PyObject *) x->ob_type;
Py_INCREF(Py_Type(x));
return (PyObject *) Py_Type(x);
}
/* SF bug 475327 -- if that didn't trigger, we need 3
@ -2176,7 +2176,7 @@ _PyType_Lookup(PyTypeObject *type, PyObject *name)
static PyObject *
type_getattro(PyTypeObject *type, PyObject *name)
{
PyTypeObject *metatype = type->ob_type;
PyTypeObject *metatype = Py_Type(type);
PyObject *meta_attribute, *attribute;
descrgetfunc meta_get;
@ -2193,7 +2193,7 @@ type_getattro(PyTypeObject *type, PyObject *name)
meta_attribute = _PyType_Lookup(metatype, name);
if (meta_attribute != NULL) {
meta_get = meta_attribute->ob_type->tp_descr_get;
meta_get = Py_Type(meta_attribute)->tp_descr_get;
if (meta_get != NULL && PyDescr_IsData(meta_attribute)) {
/* Data descriptors implement tp_descr_set to intercept
@ -2211,7 +2211,7 @@ type_getattro(PyTypeObject *type, PyObject *name)
attribute = _PyType_Lookup(type, name);
if (attribute != NULL) {
/* Implement descriptor functionality, if any */
descrgetfunc local_get = attribute->ob_type->tp_descr_get;
descrgetfunc local_get = Py_Type(attribute)->tp_descr_get;
Py_XDECREF(meta_attribute);
@ -2289,7 +2289,7 @@ type_dealloc(PyTypeObject *type)
PyObject_Free((char *)type->tp_doc);
Py_XDECREF(et->ht_name);
Py_XDECREF(et->ht_slots);
type->ob_type->tp_free((PyObject *)type);
Py_Type(type)->tp_free((PyObject *)type);
}
static PyObject *
@ -2397,8 +2397,7 @@ type_is_gc(PyTypeObject *type)
}
PyTypeObject PyType_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"type", /* tp_name */
sizeof(PyHeapTypeObject), /* tp_basicsize */
sizeof(PyMemberDef), /* tp_itemsize */
@ -2500,7 +2499,7 @@ object_init(PyObject *self, PyObject *args, PyObject *kwds)
{
int err = 0;
if (excess_args(args, kwds)) {
PyTypeObject *type = self->ob_type;
PyTypeObject *type = Py_Type(self);
if (type->tp_init != object_init &&
type->tp_new != object_new)
{
@ -2547,7 +2546,7 @@ object_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
static void
object_dealloc(PyObject *self)
{
self->ob_type->tp_free(self);
Py_Type(self)->tp_free(self);
}
static PyObject *
@ -2556,7 +2555,7 @@ object_repr(PyObject *self)
PyTypeObject *type;
PyObject *mod, *name, *rtn;
type = self->ob_type;
type = Py_Type(self);
mod = type_module(type, NULL);
if (mod == NULL)
PyErr_Clear();
@ -2585,7 +2584,7 @@ object_str(PyObject *self)
{
unaryfunc f;
f = self->ob_type->tp_repr;
f = Py_Type(self)->tp_repr;
if (f == NULL)
f = object_repr;
return f(self);
@ -2600,8 +2599,8 @@ object_hash(PyObject *self)
static PyObject *
object_get_class(PyObject *self, void *closure)
{
Py_INCREF(self->ob_type);
return (PyObject *)(self->ob_type);
Py_INCREF(Py_Type(self));
return (PyObject *)(Py_Type(self));
}
static int
@ -2686,7 +2685,7 @@ compatible_for_assignment(PyTypeObject* oldto, PyTypeObject* newto, char* attr)
static int
object_set_class(PyObject *self, PyObject *value, void *closure)
{
PyTypeObject *oldto = self->ob_type;
PyTypeObject *oldto = Py_Type(self);
PyTypeObject *newto;
if (value == NULL) {
@ -2697,7 +2696,7 @@ object_set_class(PyObject *self, PyObject *value, void *closure)
if (!PyType_Check(value)) {
PyErr_Format(PyExc_TypeError,
"__class__ must be set to new-style class, not '%s' object",
value->ob_type->tp_name);
Py_Type(value)->tp_name);
return -1;
}
newto = (PyTypeObject *)value;
@ -2710,7 +2709,7 @@ object_set_class(PyObject *self, PyObject *value, void *closure)
}
if (compatible_for_assignment(newto, oldto, "__class__")) {
Py_INCREF(newto);
self->ob_type = newto;
Py_Type(self) = newto;
Py_DECREF(oldto);
return 0;
}
@ -2806,7 +2805,7 @@ reduce_2(PyObject *obj)
if (args != NULL && !PyTuple_Check(args)) {
PyErr_Format(PyExc_TypeError,
"__getnewargs__ should return a tuple, "
"not '%.200s'", args->ob_type->tp_name);
"not '%.200s'", Py_Type(args)->tp_name);
goto end;
}
}
@ -3018,8 +3017,7 @@ static PyMethodDef object_methods[] = {
PyTypeObject PyBaseObject_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"object", /* tp_name */
sizeof(PyObject), /* tp_basicsize */
0, /* tp_itemsize */
@ -3461,8 +3459,8 @@ PyType_Ready(PyTypeObject *type)
NULL when type is &PyBaseObject_Type, and we know its ob_type is
not NULL (it's initialized to &PyType_Type). But coverity doesn't
know that. */
if (type->ob_type == NULL && base != NULL)
type->ob_type = base->ob_type;
if (Py_Type(type) == NULL && base != NULL)
Py_Type(type) = Py_Type(base);
/* Initialize tp_bases */
bases = type->tp_bases;
@ -3822,7 +3820,7 @@ getindex(PyObject *self, PyObject *arg)
if (i == -1 && PyErr_Occurred())
return -1;
if (i < 0) {
PySequenceMethods *sq = self->ob_type->tp_as_sequence;
PySequenceMethods *sq = Py_Type(self)->tp_as_sequence;
if (sq && sq->sq_length) {
Py_ssize_t n = (*sq->sq_length)(self);
if (n < 0)
@ -3998,14 +3996,14 @@ wrap_cmpfunc(PyObject *self, PyObject *args, void *wrapped)
if (!check_num_args(args, 1))
return NULL;
other = PyTuple_GET_ITEM(args, 0);
if (other->ob_type->tp_compare != func &&
!PyType_IsSubtype(other->ob_type, self->ob_type)) {
if (Py_Type(other)->tp_compare != func &&
!PyType_IsSubtype(Py_Type(other), Py_Type(self))) {
PyErr_Format(
PyExc_TypeError,
"%s.__cmp__(x,y) requires y to be a '%s', not a '%s'",
self->ob_type->tp_name,
self->ob_type->tp_name,
other->ob_type->tp_name);
Py_Type(self)->tp_name,
Py_Type(self)->tp_name,
Py_Type(other)->tp_name);
return NULL;
}
res = (*func)(self, other);
@ -4019,7 +4017,7 @@ wrap_cmpfunc(PyObject *self, PyObject *args, void *wrapped)
static int
hackcheck(PyObject *self, setattrofunc func, char *what)
{
PyTypeObject *type = self->ob_type;
PyTypeObject *type = Py_Type(self);
while (type && type->tp_flags & Py_TPFLAGS_HEAPTYPE)
type = type->tp_base;
/* If type is NULL now, this is a really weird type.
@ -4219,7 +4217,7 @@ tp_new_wrapper(PyObject *self, PyObject *args, PyObject *kwds)
PyErr_Format(PyExc_TypeError,
"%s.__new__(X): X is not a type object (%s)",
type->tp_name,
arg0->ob_type->tp_name);
Py_Type(arg0)->tp_name);
return NULL;
}
subtype = (PyTypeObject *)arg0;
@ -4310,14 +4308,14 @@ method_is_overloaded(PyObject *left, PyObject *right, char *name)
PyObject *a, *b;
int ok;
b = PyObject_GetAttrString((PyObject *)(right->ob_type), name);
b = PyObject_GetAttrString((PyObject *)(Py_Type(right)), name);
if (b == NULL) {
PyErr_Clear();
/* If right doesn't have it, it's not overloaded */
return 0;
}
a = PyObject_GetAttrString((PyObject *)(left->ob_type), name);
a = PyObject_GetAttrString((PyObject *)(Py_Type(left)), name);
if (a == NULL) {
PyErr_Clear();
Py_DECREF(b);
@ -4342,14 +4340,14 @@ static PyObject * \
FUNCNAME(PyObject *self, PyObject *other) \
{ \
static PyObject *cache_str, *rcache_str; \
int do_other = self->ob_type != other->ob_type && \
other->ob_type->tp_as_number != NULL && \
other->ob_type->tp_as_number->SLOTNAME == TESTFUNC; \
if (self->ob_type->tp_as_number != NULL && \
self->ob_type->tp_as_number->SLOTNAME == TESTFUNC) { \
int do_other = Py_Type(self) != Py_Type(other) && \
Py_Type(other)->tp_as_number != NULL && \
Py_Type(other)->tp_as_number->SLOTNAME == TESTFUNC; \
if (Py_Type(self)->tp_as_number != NULL && \
Py_Type(self)->tp_as_number->SLOTNAME == TESTFUNC) { \
PyObject *r; \
if (do_other && \
PyType_IsSubtype(other->ob_type, self->ob_type) && \
PyType_IsSubtype(Py_Type(other), Py_Type(self)) && \
method_is_overloaded(self, other, ROPSTR)) { \
r = call_maybe( \
other, ROPSTR, &rcache_str, "(O)", self); \
@ -4361,7 +4359,7 @@ FUNCNAME(PyObject *self, PyObject *other) \
r = call_maybe( \
self, OPSTR, &cache_str, "(O)", other); \
if (r != Py_NotImplemented || \
other->ob_type == self->ob_type) \
Py_Type(other) == Py_Type(self)) \
return r; \
Py_DECREF(r); \
} \
@ -4419,12 +4417,12 @@ slot_sq_item(PyObject *self, Py_ssize_t i)
if (getitem_str == NULL)
return NULL;
}
func = _PyType_Lookup(self->ob_type, getitem_str);
func = _PyType_Lookup(Py_Type(self), getitem_str);
if (func != NULL) {
if ((f = func->ob_type->tp_descr_get) == NULL)
if ((f = Py_Type(func)->tp_descr_get) == NULL)
Py_INCREF(func);
else {
func = f(func, self, (PyObject *)(self->ob_type));
func = f(func, self, (PyObject *)(Py_Type(self)));
if (func == NULL) {
return NULL;
}
@ -4563,8 +4561,8 @@ slot_nb_power(PyObject *self, PyObject *other, PyObject *modulus)
/* Three-arg power doesn't use __rpow__. But ternary_op
can call this when the second argument's type uses
slot_nb_power, so check before calling self.__pow__. */
if (self->ob_type->tp_as_number != NULL &&
self->ob_type->tp_as_number->nb_power == slot_nb_power) {
if (Py_Type(self)->tp_as_number != NULL &&
Py_Type(self)->tp_as_number->nb_power == slot_nb_power) {
return call_method(self, "__pow__", &pow_str,
"(OO)", other, modulus);
}
@ -4754,12 +4752,12 @@ _PyObject_SlotCompare(PyObject *self, PyObject *other)
{
int c;
if (self->ob_type->tp_compare == _PyObject_SlotCompare) {
if (Py_Type(self)->tp_compare == _PyObject_SlotCompare) {
c = half_compare(self, other);
if (c <= 1)
return c;
}
if (other->ob_type->tp_compare == _PyObject_SlotCompare) {
if (Py_Type(other)->tp_compare == _PyObject_SlotCompare) {
c = half_compare(other, self);
if (c < -1)
return -2;
@ -4784,7 +4782,7 @@ slot_tp_repr(PyObject *self)
}
PyErr_Clear();
return PyString_FromFormat("<%s object at %p>",
self->ob_type->tp_name, self);
Py_Type(self)->tp_name, self);
}
static PyObject *
@ -4893,7 +4891,7 @@ slot_tp_getattro(PyObject *self, PyObject *name)
static PyObject *
slot_tp_getattr_hook(PyObject *self, PyObject *name)
{
PyTypeObject *tp = self->ob_type;
PyTypeObject *tp = Py_Type(self);
PyObject *getattr, *getattribute, *res;
static PyObject *getattribute_str = NULL;
static PyObject *getattr_str = NULL;
@ -4917,7 +4915,7 @@ slot_tp_getattr_hook(PyObject *self, PyObject *name)
}
getattribute = _PyType_Lookup(tp, getattribute_str);
if (getattribute == NULL ||
(getattribute->ob_type == &PyWrapperDescr_Type &&
(Py_Type(getattribute) == &PyWrapperDescr_Type &&
((PyWrapperDescrObject *)getattribute)->d_wrapped ==
(void *)PyObject_GenericGetAttr))
res = PyObject_GenericGetAttr(self, name);
@ -4986,13 +4984,13 @@ slot_tp_richcompare(PyObject *self, PyObject *other, int op)
{
PyObject *res;
if (self->ob_type->tp_richcompare == slot_tp_richcompare) {
if (Py_Type(self)->tp_richcompare == slot_tp_richcompare) {
res = half_richcompare(self, other, op);
if (res != Py_NotImplemented)
return res;
Py_DECREF(res);
}
if (other->ob_type->tp_richcompare == slot_tp_richcompare) {
if (Py_Type(other)->tp_richcompare == slot_tp_richcompare) {
res = half_richcompare(other, self, _Py_SwappedOp[op]);
if (res != Py_NotImplemented) {
return res;
@ -5025,7 +5023,7 @@ slot_tp_iter(PyObject *self)
if (func == NULL) {
PyErr_Format(PyExc_TypeError,
"'%.200s' object is not iterable",
self->ob_type->tp_name);
Py_Type(self)->tp_name);
return NULL;
}
Py_DECREF(func);
@ -5042,7 +5040,7 @@ slot_tp_iternext(PyObject *self)
static PyObject *
slot_tp_descr_get(PyObject *self, PyObject *obj, PyObject *type)
{
PyTypeObject *tp = self->ob_type;
PyTypeObject *tp = Py_Type(self);
PyObject *get;
static PyObject *get_str = NULL;
@ -5100,7 +5098,7 @@ slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds)
if (res != Py_None) {
PyErr_Format(PyExc_TypeError,
"__init__() should return None, not '%.200s'",
res->ob_type->tp_name);
Py_Type(res)->tp_name);
Py_DECREF(res);
return -1;
}
@ -5185,7 +5183,7 @@ slot_tp_del(PyObject *self)
_Py_NewReference(self);
self->ob_refcnt = refcnt;
}
assert(!PyType_IS_GC(self->ob_type) ||
assert(!PyType_IS_GC(Py_Type(self)) ||
_Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED);
/* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
* we need to undo that. */
@ -5197,8 +5195,8 @@ slot_tp_del(PyObject *self)
* undone.
*/
#ifdef COUNT_ALLOCS
--self->ob_type->tp_frees;
--self->ob_type->tp_allocs;
--Py_Type(self)->tp_frees;
--Py_Type(self)->tp_allocs;
#endif
}
@ -5560,7 +5558,7 @@ update_one_slot(PyTypeObject *type, slotdef *p)
descr = _PyType_Lookup(type, p->name_strobj);
if (descr == NULL)
continue;
if (descr->ob_type == &PyWrapperDescr_Type) {
if (Py_Type(descr) == &PyWrapperDescr_Type) {
void **tptr = resolve_slotdups(type, p->name_strobj);
if (tptr == NULL || tptr == ptr)
generic = p->function;
@ -5575,7 +5573,7 @@ update_one_slot(PyTypeObject *type, slotdef *p)
use_generic = 1;
}
}
else if (descr->ob_type == &PyCFunction_Type &&
else if (Py_Type(descr) == &PyCFunction_Type &&
PyCFunction_GET_FUNCTION(descr) ==
(PyCFunction)tp_new_wrapper &&
strcmp(p->name, "__new__") == 0)
@ -5846,7 +5844,7 @@ super_dealloc(PyObject *self)
Py_XDECREF(su->obj);
Py_XDECREF(su->type);
Py_XDECREF(su->obj_type);
self->ob_type->tp_free(self);
Py_Type(self)->tp_free(self);
}
static PyObject *
@ -5911,7 +5909,7 @@ super_getattro(PyObject *self, PyObject *name)
res = PyDict_GetItem(dict, name);
if (res != NULL) {
Py_INCREF(res);
f = res->ob_type->tp_descr_get;
f = Py_Type(res)->tp_descr_get;
if (f != NULL) {
tmp = f(res,
/* Only pass 'obj' param if
@ -5947,7 +5945,7 @@ supercheck(PyTypeObject *type, PyObject *obj)
the normal case; the return value is obj.__class__.
But... when obj is an instance, we want to allow for the case where
obj->ob_type is not a subclass of type, but obj.__class__ is!
Py_Type(obj) is not a subclass of type, but obj.__class__ is!
This will allow using super() with a proxy for obj.
*/
@ -5958,9 +5956,9 @@ supercheck(PyTypeObject *type, PyObject *obj)
}
/* Normal case */
if (PyType_IsSubtype(obj->ob_type, type)) {
Py_INCREF(obj->ob_type);
return obj->ob_type;
if (PyType_IsSubtype(Py_Type(obj), type)) {
Py_INCREF(Py_Type(obj));
return Py_Type(obj);
}
else {
/* Try the slow way */
@ -5977,7 +5975,7 @@ supercheck(PyTypeObject *type, PyObject *obj)
if (class_attr != NULL &&
PyType_Check(class_attr) &&
(PyTypeObject *)class_attr != obj->ob_type)
(PyTypeObject *)class_attr != Py_Type(obj))
{
int ok = PyType_IsSubtype(
(PyTypeObject *)class_attr, type);
@ -6008,10 +6006,10 @@ super_descr_get(PyObject *self, PyObject *obj, PyObject *type)
Py_INCREF(self);
return self;
}
if (su->ob_type != &PySuper_Type)
if (Py_Type(su) != &PySuper_Type)
/* If su is an instance of a (strict) subclass of super,
call its type */
return PyObject_CallFunctionObjArgs((PyObject *)su->ob_type,
return PyObject_CallFunctionObjArgs((PyObject *)Py_Type(su),
su->type, obj, NULL);
else {
/* Inline the common case */
@ -6080,8 +6078,7 @@ super_traverse(PyObject *self, visitproc visit, void *arg)
}
PyTypeObject PySuper_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"super", /* tp_name */
sizeof(superobject), /* tp_basicsize */
0, /* tp_itemsize */

28
Objects/unicodeobject.c
View file

@ -312,7 +312,7 @@ void unicode_dealloc(register PyUnicodeObject *unicode)
else {
PyMem_DEL(unicode->str);
Py_XDECREF(unicode->defenc);
unicode->ob_type->tp_free((PyObject *)unicode);
Py_Type(unicode)->tp_free((PyObject *)unicode);
}
}
@ -326,7 +326,7 @@ int PyUnicode_Resize(PyObject **unicode, Py_ssize_t length)
return -1;
}
v = (PyUnicodeObject *)*unicode;
if (v == NULL || !PyUnicode_Check(v) || v->ob_refcnt != 1 || length < 0) {
if (v == NULL || !PyUnicode_Check(v) || Py_Refcnt(v) != 1 || length < 0) {
PyErr_BadInternalCall();
return -1;
}
@ -554,7 +554,7 @@ PyObject *PyUnicode_FromEncodedObject(register PyObject *obj,
PyErr_Format(PyExc_TypeError,
"coercing to Unicode: need string or buffer, "
"%.80s found",
obj->ob_type->tp_name);
Py_Type(obj)->tp_name);
goto onError;
}
@ -604,7 +604,7 @@ PyObject *PyUnicode_Decode(const char *s,
if (!PyUnicode_Check(unicode)) {
PyErr_Format(PyExc_TypeError,
"decoder did not return an unicode object (type=%.400s)",
unicode->ob_type->tp_name);
Py_Type(unicode)->tp_name);
Py_DECREF(unicode);
goto onError;
}
@ -714,7 +714,7 @@ PyObject *PyUnicode_AsEncodedString(PyObject *unicode,
if (!PyString_Check(v)) {
PyErr_Format(PyExc_TypeError,
"encoder did not return a string object (type=%.400s)",
v->ob_type->tp_name);
Py_Type(v)->tp_name);
Py_DECREF(v);
goto onError;
}
@ -3242,8 +3242,7 @@ encoding_map_dealloc(PyObject* o)
}
static PyTypeObject EncodingMapType = {
PyObject_HEAD_INIT(NULL)
0, /*ob_size*/
PyVarObject_HEAD_INIT(NULL, 0)
"EncodingMap", /*tp_name*/
sizeof(struct encoding_map), /*tp_basicsize*/
0, /*tp_itemsize*/
@ -3502,7 +3501,7 @@ charmapencode_result charmapencode_output(Py_UNICODE c, PyObject *mapping,
char *outstart;
Py_ssize_t outsize = PyString_GET_SIZE(*outobj);
if (mapping->ob_type == &EncodingMapType) {
if (Py_Type(mapping) == &EncodingMapType) {
int res = encoding_map_lookup(c, mapping);
Py_ssize_t requiredsize = *outpos+1;
if (res == -1)
@ -3574,7 +3573,7 @@ int charmap_encoding_error(
/* find all unencodable characters */
while (collendpos < size) {
PyObject *rep;
if (mapping->ob_type == &EncodingMapType) {
if (Py_Type(mapping) == &EncodingMapType) {
int res = encoding_map_lookup(p[collendpos], mapping);
if (res != -1)
break;
@ -4632,7 +4631,7 @@ PyUnicode_Join(PyObject *separator, PyObject *seq)
PyErr_Format(PyExc_TypeError,
"sequence item %zd: expected string or Unicode,"
" %.80s found",
i, item->ob_type->tp_name);
i, Py_Type(item)->tp_name);
goto onError;
}
item = PyUnicode_FromObject(item);
@ -5632,7 +5631,7 @@ unicode_encode(PyUnicodeObject *self, PyObject *args)
PyErr_Format(PyExc_TypeError,
"encoder did not return a string/unicode object "
"(type=%.400s)",
v->ob_type->tp_name);
Py_Type(v)->tp_name);
Py_DECREF(v);
return NULL;
}
@ -5668,7 +5667,7 @@ unicode_decode(PyUnicodeObject *self, PyObject *args)
PyErr_Format(PyExc_TypeError,
"decoder did not return a string/unicode object "
"(type=%.400s)",
v->ob_type->tp_name);
Py_Type(v)->tp_name);
Py_DECREF(v);
return NULL;
}
@ -7499,7 +7498,7 @@ PyObject *PyUnicode_Format(PyObject *format,
arglen = -1;
argidx = -2;
}
if (args->ob_type->tp_as_mapping && !PyTuple_Check(args) &&
if (Py_Type(args)->tp_as_mapping && !PyTuple_Check(args) &&
!PyObject_TypeCheck(args, &PyBaseString_Type))
dict = args;
@ -7963,8 +7962,7 @@ encoding defaults to the current default string encoding.\n\
errors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'.");
PyTypeObject PyUnicode_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0, /* ob_size */
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"unicode", /* tp_name */
sizeof(PyUnicodeObject), /* tp_size */
0, /* tp_itemsize */

33
Objects/weakrefobject.c
View file

@ -105,7 +105,7 @@ weakref_dealloc(PyObject *self)
{
PyObject_GC_UnTrack(self);
clear_weakref((PyWeakReference *) self);
self->ob_type->tp_free(self);
Py_Type(self)->tp_free(self);
}
@ -172,7 +172,7 @@ weakref_repr(PyWeakReference *self)
name ? "<weakref at %p; to '%.50s' at %p (%s)>"
: "<weakref at %p; to '%.50s' at %p>",
self,
PyWeakref_GET_OBJECT(self)->ob_type->tp_name,
Py_Type(PyWeakref_GET_OBJECT(self))->tp_name,
PyWeakref_GET_OBJECT(self),
name);
Py_XDECREF(nameobj);
@ -274,10 +274,10 @@ weakref___new__(PyTypeObject *type, PyObject *args, PyObject *kwargs)
PyWeakReference *ref, *proxy;
PyWeakReference **list;
if (!PyType_SUPPORTS_WEAKREFS(ob->ob_type)) {
if (!PyType_SUPPORTS_WEAKREFS(Py_Type(ob))) {
PyErr_Format(PyExc_TypeError,
"cannot create weak reference to '%s' object",
ob->ob_type->tp_name);
Py_Type(ob)->tp_name);
return NULL;
}
if (callback == Py_None)
@ -332,8 +332,7 @@ weakref___init__(PyObject *self, PyObject *args, PyObject *kwargs)
PyTypeObject
_PyWeakref_RefType = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"weakref",
sizeof(PyWeakReference),
0,
@ -447,7 +446,7 @@ proxy_repr(PyWeakReference *proxy)
char buf[160];
PyOS_snprintf(buf, sizeof(buf),
"<weakproxy at %p to %.100s at %p>", proxy,
PyWeakref_GET_OBJECT(proxy)->ob_type->tp_name,
Py_Type(PyWeakref_GET_OBJECT(proxy))->tp_name,
PyWeakref_GET_OBJECT(proxy));
return PyString_FromString(buf);
}
@ -646,8 +645,7 @@ static PyMappingMethods proxy_as_mapping = {
PyTypeObject
_PyWeakref_ProxyType = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"weakproxy",
sizeof(PyWeakReference),
0,
@ -681,8 +679,7 @@ _PyWeakref_ProxyType = {
PyTypeObject
_PyWeakref_CallableProxyType = {
PyObject_HEAD_INIT(&PyType_Type)
0,
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"weakcallableproxy",
sizeof(PyWeakReference),
0,
@ -722,10 +719,10 @@ PyWeakref_NewRef(PyObject *ob, PyObject *callback)
PyWeakReference **list;
PyWeakReference *ref, *proxy;
if (!PyType_SUPPORTS_WEAKREFS(ob->ob_type)) {
if (!PyType_SUPPORTS_WEAKREFS(Py_Type(ob))) {
PyErr_Format(PyExc_TypeError,
"cannot create weak reference to '%s' object",
ob->ob_type->tp_name);
Py_Type(ob)->tp_name);
return NULL;
}
list = GET_WEAKREFS_LISTPTR(ob);
@ -781,10 +778,10 @@ PyWeakref_NewProxy(PyObject *ob, PyObject *callback)
PyWeakReference **list;
PyWeakReference *ref, *proxy;
if (!PyType_SUPPORTS_WEAKREFS(ob->ob_type)) {
if (!PyType_SUPPORTS_WEAKREFS(Py_Type(ob))) {
PyErr_Format(PyExc_TypeError,
"cannot create weak reference to '%s' object",
ob->ob_type->tp_name);
Py_Type(ob)->tp_name);
return NULL;
}
list = GET_WEAKREFS_LISTPTR(ob);
@ -807,9 +804,9 @@ PyWeakref_NewProxy(PyObject *ob, PyObject *callback)
PyWeakReference *prev;
if (PyCallable_Check(ob))
result->ob_type = &_PyWeakref_CallableProxyType;
Py_Type(result) = &_PyWeakref_CallableProxyType;
else
result->ob_type = &_PyWeakref_ProxyType;
Py_Type(result) = &_PyWeakref_ProxyType;
get_basic_refs(*list, &ref, &proxy);
if (callback == NULL) {
if (proxy != NULL) {
@ -874,7 +871,7 @@ PyObject_ClearWeakRefs(PyObject *object)
PyWeakReference **list;
if (object == NULL
|| !PyType_SUPPORTS_WEAKREFS(object->ob_type)
|| !PyType_SUPPORTS_WEAKREFS(Py_Type(object))
|| object->ob_refcnt != 0) {
PyErr_BadInternalCall();
return;