mirror of
https://github.com/python/cpython.git
synced 2025-10-31 05:31:20 +00:00
PEP 3123: Provide forward compatibility with Python 3.0, while keeping
backwards compatibility. Add Py_Refcnt, Py_Type, Py_Size, and PyVarObject_HEAD_INIT.
This commit is contained in:
Martin v. Löwis
parent
b1994b4a5d
commit
6819210b9e
129 changed files with 1090 additions and 1250 deletions
|
|
@ -39,7 +39,7 @@ typedef struct arrayobject {
|
|||
static PyTypeObject Arraytype;
|
||||
|
||||
#define array_Check(op) PyObject_TypeCheck(op, &Arraytype)
|
||||
#define array_CheckExact(op) ((op)->ob_type == &Arraytype)
|
||||
#define array_CheckExact(op) (Py_Type(op) == &Arraytype)
|
||||
|
||||
static int
|
||||
array_resize(arrayobject *self, Py_ssize_t newsize)
|
||||
|
|
@ -53,9 +53,9 @@ array_resize(arrayobject *self, Py_ssize_t newsize)
|
|||
*/
|
||||
|
||||
if (self->allocated >= newsize &&
|
||||
self->ob_size < newsize + 16 &&
|
||||
Py_Size(self) < newsize + 16 &&
|
||||
self->ob_item != NULL) {
|
||||
self->ob_size = newsize;
|
||||
Py_Size(self) = newsize;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -71,7 +71,7 @@ array_resize(arrayobject *self, Py_ssize_t newsize)
|
|||
* memory critical.
|
||||
*/
|
||||
|
||||
_new_size = (newsize >> 4) + (self->ob_size < 8 ? 3 : 7) + newsize;
|
||||
_new_size = (newsize >> 4) + (Py_Size(self) < 8 ? 3 : 7) + newsize;
|
||||
items = self->ob_item;
|
||||
/* XXX The following multiplication and division does not optimize away
|
||||
like it does for lists since the size is not known at compile time */
|
||||
|
|
@ -84,7 +84,7 @@ array_resize(arrayobject *self, Py_ssize_t newsize)
|
|||
return -1;
|
||||
}
|
||||
self->ob_item = items;
|
||||
self->ob_size = newsize;
|
||||
Py_Size(self) = newsize;
|
||||
self->allocated = _new_size;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -432,7 +432,7 @@ newarrayobject(PyTypeObject *type, Py_ssize_t size, struct arraydescr *descr)
|
|||
if (op == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
op->ob_size = size;
|
||||
Py_Size(op) = size;
|
||||
if (size <= 0) {
|
||||
op->ob_item = NULL;
|
||||
}
|
||||
|
|
@ -455,7 +455,7 @@ getarrayitem(PyObject *op, Py_ssize_t i)
|
|||
register arrayobject *ap;
|
||||
assert(array_Check(op));
|
||||
ap = (arrayobject *)op;
|
||||
assert(i>=0 && i<ap->ob_size);
|
||||
assert(i>=0 && i<Py_Size(ap));
|
||||
return (*ap->ob_descr->getitem)(ap, i);
|
||||
}
|
||||
|
||||
|
|
@ -463,7 +463,7 @@ static int
|
|||
ins1(arrayobject *self, Py_ssize_t where, PyObject *v)
|
||||
{
|
||||
char *items;
|
||||
Py_ssize_t n = self->ob_size;
|
||||
Py_ssize_t n = Py_Size(self);
|
||||
if (v == NULL) {
|
||||
PyErr_BadInternalCall();
|
||||
return -1;
|
||||
|
|
@ -498,7 +498,7 @@ array_dealloc(arrayobject *op)
|
|||
PyObject_ClearWeakRefs((PyObject *) op);
|
||||
if (op->ob_item != NULL)
|
||||
PyMem_DEL(op->ob_item);
|
||||
op->ob_type->tp_free((PyObject *)op);
|
||||
Py_Type(op)->tp_free((PyObject *)op);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
|
|
@ -518,7 +518,7 @@ array_richcompare(PyObject *v, PyObject *w, int op)
|
|||
va = (arrayobject *)v;
|
||||
wa = (arrayobject *)w;
|
||||
|
||||
if (va->ob_size != wa->ob_size && (op == Py_EQ || op == Py_NE)) {
|
||||
if (Py_Size(va) != Py_Size(wa) && (op == Py_EQ || op == Py_NE)) {
|
||||
/* Shortcut: if the lengths differ, the arrays differ */
|
||||
if (op == Py_EQ)
|
||||
res = Py_False;
|
||||
|
|
@ -530,7 +530,7 @@ array_richcompare(PyObject *v, PyObject *w, int op)
|
|||
|
||||
/* Search for the first index where items are different */
|
||||
k = 1;
|
||||
for (i = 0; i < va->ob_size && i < wa->ob_size; i++) {
|
||||
for (i = 0; i < Py_Size(va) && i < Py_Size(wa); i++) {
|
||||
vi = getarrayitem(v, i);
|
||||
wi = getarrayitem(w, i);
|
||||
if (vi == NULL || wi == NULL) {
|
||||
|
|
@ -549,8 +549,8 @@ array_richcompare(PyObject *v, PyObject *w, int op)
|
|||
|
||||
if (k) {
|
||||
/* No more items to compare -- compare sizes */
|
||||
Py_ssize_t vs = va->ob_size;
|
||||
Py_ssize_t ws = wa->ob_size;
|
||||
Py_ssize_t vs = Py_Size(va);
|
||||
Py_ssize_t ws = Py_Size(wa);
|
||||
int cmp;
|
||||
switch (op) {
|
||||
case Py_LT: cmp = vs < ws; break;
|
||||
|
|
@ -590,13 +590,13 @@ array_richcompare(PyObject *v, PyObject *w, int op)
|
|||
static Py_ssize_t
|
||||
array_length(arrayobject *a)
|
||||
{
|
||||
return a->ob_size;
|
||||
return Py_Size(a);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
array_item(arrayobject *a, Py_ssize_t i)
|
||||
{
|
||||
if (i < 0 || i >= a->ob_size) {
|
||||
if (i < 0 || i >= Py_Size(a)) {
|
||||
PyErr_SetString(PyExc_IndexError, "array index out of range");
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -609,14 +609,14 @@ array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
|
|||
arrayobject *np;
|
||||
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 < 0)
|
||||
ihigh = 0;
|
||||
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);
|
||||
np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr);
|
||||
if (np == NULL)
|
||||
return NULL;
|
||||
|
|
@ -628,7 +628,7 @@ array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
|
|||
static PyObject *
|
||||
array_copy(arrayobject *a, PyObject *unused)
|
||||
{
|
||||
return array_slice(a, 0, a->ob_size);
|
||||
return array_slice(a, 0, Py_Size(a));
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(copy_doc,
|
||||
|
|
@ -644,7 +644,7 @@ array_concat(arrayobject *a, PyObject *bb)
|
|||
if (!array_Check(bb)) {
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"can only append array (not \"%.200s\") to array",
|
||||
bb->ob_type->tp_name);
|
||||
Py_Type(bb)->tp_name);
|
||||
return NULL;
|
||||
}
|
||||
#define b ((arrayobject *)bb)
|
||||
|
|
@ -652,14 +652,14 @@ array_concat(arrayobject *a, PyObject *bb)
|
|||
PyErr_BadArgument();
|
||||
return NULL;
|
||||
}
|
||||
size = a->ob_size + b->ob_size;
|
||||
size = Py_Size(a) + Py_Size(b);
|
||||
np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
|
||||
if (np == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
memcpy(np->ob_item, a->ob_item, a->ob_size*a->ob_descr->itemsize);
|
||||
memcpy(np->ob_item + a->ob_size*a->ob_descr->itemsize,
|
||||
b->ob_item, b->ob_size*b->ob_descr->itemsize);
|
||||
memcpy(np->ob_item, a->ob_item, Py_Size(a)*a->ob_descr->itemsize);
|
||||
memcpy(np->ob_item + Py_Size(a)*a->ob_descr->itemsize,
|
||||
b->ob_item, Py_Size(b)*b->ob_descr->itemsize);
|
||||
return (PyObject *)np;
|
||||
#undef b
|
||||
}
|
||||
|
|
@ -674,12 +674,12 @@ array_repeat(arrayobject *a, Py_ssize_t n)
|
|||
Py_ssize_t nbytes;
|
||||
if (n < 0)
|
||||
n = 0;
|
||||
size = a->ob_size * n;
|
||||
size = Py_Size(a) * n;
|
||||
np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
|
||||
if (np == NULL)
|
||||
return NULL;
|
||||
p = np->ob_item;
|
||||
nbytes = a->ob_size * a->ob_descr->itemsize;
|
||||
nbytes = Py_Size(a) * a->ob_descr->itemsize;
|
||||
for (i = 0; i < n; i++) {
|
||||
memcpy(p, a->ob_item, nbytes);
|
||||
p += nbytes;
|
||||
|
|
@ -697,7 +697,7 @@ array_ass_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
|
|||
if (v == NULL)
|
||||
n = 0;
|
||||
else if (array_Check(v)) {
|
||||
n = b->ob_size;
|
||||
n = Py_Size(b);
|
||||
if (a == b) {
|
||||
/* Special case "a[i:j] = a" -- copy b first */
|
||||
int ret;
|
||||
|
|
@ -716,44 +716,44 @@ array_ass_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
|
|||
else {
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"can only assign array (not \"%.200s\") to array slice",
|
||||
v->ob_type->tp_name);
|
||||
Py_Type(v)->tp_name);
|
||||
return -1;
|
||||
}
|
||||
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 < 0)
|
||||
ihigh = 0;
|
||||
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);
|
||||
item = a->ob_item;
|
||||
d = n - (ihigh-ilow);
|
||||
if (d < 0) { /* Delete -d items */
|
||||
memmove(item + (ihigh+d)*a->ob_descr->itemsize,
|
||||
item + ihigh*a->ob_descr->itemsize,
|
||||
(a->ob_size-ihigh)*a->ob_descr->itemsize);
|
||||
a->ob_size += d;
|
||||
PyMem_RESIZE(item, char, a->ob_size*a->ob_descr->itemsize);
|
||||
(Py_Size(a)-ihigh)*a->ob_descr->itemsize);
|
||||
Py_Size(a) += d;
|
||||
PyMem_RESIZE(item, char, Py_Size(a)*a->ob_descr->itemsize);
|
||||
/* Can't fail */
|
||||
a->ob_item = item;
|
||||
a->allocated = a->ob_size;
|
||||
a->allocated = Py_Size(a);
|
||||
}
|
||||
else if (d > 0) { /* Insert d items */
|
||||
PyMem_RESIZE(item, char,
|
||||
(a->ob_size + d)*a->ob_descr->itemsize);
|
||||
(Py_Size(a) + d)*a->ob_descr->itemsize);
|
||||
if (item == NULL) {
|
||||
PyErr_NoMemory();
|
||||
return -1;
|
||||
}
|
||||
memmove(item + (ihigh+d)*a->ob_descr->itemsize,
|
||||
item + ihigh*a->ob_descr->itemsize,
|
||||
(a->ob_size-ihigh)*a->ob_descr->itemsize);
|
||||
(Py_Size(a)-ihigh)*a->ob_descr->itemsize);
|
||||
a->ob_item = item;
|
||||
a->ob_size += d;
|
||||
a->allocated = a->ob_size;
|
||||
Py_Size(a) += d;
|
||||
a->allocated = Py_Size(a);
|
||||
}
|
||||
if (n > 0)
|
||||
memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,
|
||||
|
|
@ -765,7 +765,7 @@ array_ass_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
|
|||
static int
|
||||
array_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v)
|
||||
{
|
||||
if (i < 0 || i >= a->ob_size) {
|
||||
if (i < 0 || i >= Py_Size(a)) {
|
||||
PyErr_SetString(PyExc_IndexError,
|
||||
"array assignment index out of range");
|
||||
return -1;
|
||||
|
|
@ -792,7 +792,7 @@ array_iter_extend(arrayobject *self, PyObject *bb)
|
|||
return -1;
|
||||
|
||||
while ((v = PyIter_Next(it)) != NULL) {
|
||||
if (ins1(self, (int) self->ob_size, v) != 0) {
|
||||
if (ins1(self, (int) Py_Size(self), v) != 0) {
|
||||
Py_DECREF(v);
|
||||
Py_DECREF(it);
|
||||
return -1;
|
||||
|
|
@ -818,16 +818,16 @@ array_do_extend(arrayobject *self, PyObject *bb)
|
|||
"can only extend with array of same kind");
|
||||
return -1;
|
||||
}
|
||||
size = self->ob_size + b->ob_size;
|
||||
size = Py_Size(self) + Py_Size(b);
|
||||
PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);
|
||||
if (self->ob_item == NULL) {
|
||||
PyObject_Del(self);
|
||||
PyErr_NoMemory();
|
||||
return -1;
|
||||
}
|
||||
memcpy(self->ob_item + self->ob_size*self->ob_descr->itemsize,
|
||||
b->ob_item, b->ob_size*b->ob_descr->itemsize);
|
||||
self->ob_size = size;
|
||||
memcpy(self->ob_item + Py_Size(self)*self->ob_descr->itemsize,
|
||||
b->ob_item, Py_Size(b)*b->ob_descr->itemsize);
|
||||
Py_Size(self) = size;
|
||||
self->allocated = size;
|
||||
|
||||
return 0;
|
||||
|
|
@ -840,7 +840,7 @@ array_inplace_concat(arrayobject *self, PyObject *bb)
|
|||
if (!array_Check(bb)) {
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"can only extend array with array (not \"%.200s\")",
|
||||
bb->ob_type->tp_name);
|
||||
Py_Type(bb)->tp_name);
|
||||
return NULL;
|
||||
}
|
||||
if (array_do_extend(self, bb) == -1)
|
||||
|
|
@ -855,15 +855,15 @@ array_inplace_repeat(arrayobject *self, Py_ssize_t n)
|
|||
char *items, *p;
|
||||
Py_ssize_t size, i;
|
||||
|
||||
if (self->ob_size > 0) {
|
||||
if (Py_Size(self) > 0) {
|
||||
if (n < 0)
|
||||
n = 0;
|
||||
items = self->ob_item;
|
||||
size = self->ob_size * self->ob_descr->itemsize;
|
||||
size = Py_Size(self) * self->ob_descr->itemsize;
|
||||
if (n == 0) {
|
||||
PyMem_FREE(items);
|
||||
self->ob_item = NULL;
|
||||
self->ob_size = 0;
|
||||
Py_Size(self) = 0;
|
||||
self->allocated = 0;
|
||||
}
|
||||
else {
|
||||
|
|
@ -876,8 +876,8 @@ array_inplace_repeat(arrayobject *self, Py_ssize_t n)
|
|||
memcpy(p, items, size);
|
||||
}
|
||||
self->ob_item = items;
|
||||
self->ob_size *= n;
|
||||
self->allocated = self->ob_size;
|
||||
Py_Size(self) *= n;
|
||||
self->allocated = Py_Size(self);
|
||||
}
|
||||
}
|
||||
Py_INCREF(self);
|
||||
|
|
@ -900,7 +900,7 @@ array_count(arrayobject *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++) {
|
||||
PyObject *selfi = getarrayitem((PyObject *)self, i);
|
||||
int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
|
||||
Py_DECREF(selfi);
|
||||
|
|
@ -922,7 +922,7 @@ array_index(arrayobject *self, PyObject *v)
|
|||
{
|
||||
Py_ssize_t i;
|
||||
|
||||
for (i = 0; i < self->ob_size; i++) {
|
||||
for (i = 0; i < Py_Size(self); i++) {
|
||||
PyObject *selfi = getarrayitem((PyObject *)self, i);
|
||||
int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
|
||||
Py_DECREF(selfi);
|
||||
|
|
@ -947,7 +947,7 @@ array_contains(arrayobject *self, PyObject *v)
|
|||
Py_ssize_t i;
|
||||
int cmp;
|
||||
|
||||
for (i = 0, cmp = 0 ; cmp == 0 && i < self->ob_size; i++) {
|
||||
for (i = 0, cmp = 0 ; cmp == 0 && i < Py_Size(self); i++) {
|
||||
PyObject *selfi = getarrayitem((PyObject *)self, i);
|
||||
cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
|
||||
Py_DECREF(selfi);
|
||||
|
|
@ -960,7 +960,7 @@ array_remove(arrayobject *self, PyObject *v)
|
|||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < self->ob_size; i++) {
|
||||
for (i = 0; i < Py_Size(self); i++) {
|
||||
PyObject *selfi = getarrayitem((PyObject *)self,i);
|
||||
int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
|
||||
Py_DECREF(selfi);
|
||||
|
|
@ -990,14 +990,14 @@ array_pop(arrayobject *self, PyObject *args)
|
|||
PyObject *v;
|
||||
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 array");
|
||||
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;
|
||||
}
|
||||
|
|
@ -1053,7 +1053,7 @@ array_buffer_info(arrayobject *self, PyObject *unused)
|
|||
return NULL;
|
||||
|
||||
PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
|
||||
PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(self->ob_size)));
|
||||
PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(Py_Size(self))));
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
|
@ -1070,7 +1070,7 @@ the buffer length in bytes.");
|
|||
static PyObject *
|
||||
array_append(arrayobject *self, PyObject *v)
|
||||
{
|
||||
return ins(self, (int) self->ob_size, v);
|
||||
return ins(self, (int) Py_Size(self), v);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(append_doc,
|
||||
|
|
@ -1089,14 +1089,14 @@ array_byteswap(arrayobject *self, PyObject *unused)
|
|||
case 1:
|
||||
break;
|
||||
case 2:
|
||||
for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 2) {
|
||||
for (p = self->ob_item, i = Py_Size(self); --i >= 0; p += 2) {
|
||||
char p0 = p[0];
|
||||
p[0] = p[1];
|
||||
p[1] = p0;
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 4) {
|
||||
for (p = self->ob_item, i = Py_Size(self); --i >= 0; p += 4) {
|
||||
char p0 = p[0];
|
||||
char p1 = p[1];
|
||||
p[0] = p[3];
|
||||
|
|
@ -1106,7 +1106,7 @@ array_byteswap(arrayobject *self, PyObject *unused)
|
|||
}
|
||||
break;
|
||||
case 8:
|
||||
for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 8) {
|
||||
for (p = self->ob_item, i = Py_Size(self); --i >= 0; p += 8) {
|
||||
char p0 = p[0];
|
||||
char p1 = p[1];
|
||||
char p2 = p[2];
|
||||
|
|
@ -1147,16 +1147,16 @@ array_reduce(arrayobject *array)
|
|||
dict = Py_None;
|
||||
Py_INCREF(dict);
|
||||
}
|
||||
if (array->ob_size > 0) {
|
||||
if (Py_Size(array) > 0) {
|
||||
result = Py_BuildValue("O(cs#)O",
|
||||
array->ob_type,
|
||||
Py_Type(array),
|
||||
array->ob_descr->typecode,
|
||||
array->ob_item,
|
||||
array->ob_size * array->ob_descr->itemsize,
|
||||
Py_Size(array) * array->ob_descr->itemsize,
|
||||
dict);
|
||||
} else {
|
||||
result = Py_BuildValue("O(c)O",
|
||||
array->ob_type,
|
||||
Py_Type(array),
|
||||
array->ob_descr->typecode,
|
||||
dict);
|
||||
}
|
||||
|
|
@ -1175,9 +1175,9 @@ array_reverse(arrayobject *self, PyObject *unused)
|
|||
char tmp[256]; /* 8 is probably enough -- but why skimp */
|
||||
assert((size_t)itemsize <= sizeof(tmp));
|
||||
|
||||
if (self->ob_size > 1) {
|
||||
if (Py_Size(self) > 1) {
|
||||
for (p = self->ob_item,
|
||||
q = self->ob_item + (self->ob_size - 1)*itemsize;
|
||||
q = self->ob_item + (Py_Size(self) - 1)*itemsize;
|
||||
p < q;
|
||||
p += itemsize, q -= itemsize) {
|
||||
/* memory areas guaranteed disjoint, so memcpy
|
||||
|
|
@ -1218,7 +1218,7 @@ array_fromfile(arrayobject *self, PyObject *args)
|
|||
Py_ssize_t newlength;
|
||||
size_t newbytes;
|
||||
/* Be careful here about overflow */
|
||||
if ((newlength = self->ob_size + n) <= 0 ||
|
||||
if ((newlength = Py_Size(self) + n) <= 0 ||
|
||||
(newbytes = newlength * itemsize) / itemsize !=
|
||||
(size_t)newlength)
|
||||
goto nomem;
|
||||
|
|
@ -1229,15 +1229,15 @@ array_fromfile(arrayobject *self, PyObject *args)
|
|||
return NULL;
|
||||
}
|
||||
self->ob_item = item;
|
||||
self->ob_size += n;
|
||||
self->allocated = self->ob_size;
|
||||
nread = fread(item + (self->ob_size - n) * itemsize,
|
||||
Py_Size(self) += n;
|
||||
self->allocated = Py_Size(self);
|
||||
nread = fread(item + (Py_Size(self) - n) * itemsize,
|
||||
itemsize, n, fp);
|
||||
if (nread < (size_t)n) {
|
||||
self->ob_size -= (n - nread);
|
||||
PyMem_RESIZE(item, char, self->ob_size*itemsize);
|
||||
Py_Size(self) -= (n - nread);
|
||||
PyMem_RESIZE(item, char, Py_Size(self)*itemsize);
|
||||
self->ob_item = item;
|
||||
self->allocated = self->ob_size;
|
||||
self->allocated = Py_Size(self);
|
||||
PyErr_SetString(PyExc_EOFError,
|
||||
"not enough items in file");
|
||||
return NULL;
|
||||
|
|
@ -1297,23 +1297,23 @@ array_fromlist(arrayobject *self, PyObject *list)
|
|||
if (n > 0) {
|
||||
char *item = self->ob_item;
|
||||
Py_ssize_t i;
|
||||
PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize);
|
||||
PyMem_RESIZE(item, char, (Py_Size(self) + n) * itemsize);
|
||||
if (item == NULL) {
|
||||
PyErr_NoMemory();
|
||||
return NULL;
|
||||
}
|
||||
self->ob_item = item;
|
||||
self->ob_size += n;
|
||||
self->allocated = self->ob_size;
|
||||
Py_Size(self) += n;
|
||||
self->allocated = Py_Size(self);
|
||||
for (i = 0; i < n; i++) {
|
||||
PyObject *v = PyList_GetItem(list, i);
|
||||
if ((*self->ob_descr->setitem)(self,
|
||||
self->ob_size - n + i, v) != 0) {
|
||||
self->ob_size -= n;
|
||||
Py_Size(self) - n + i, v) != 0) {
|
||||
Py_Size(self) -= n;
|
||||
PyMem_RESIZE(item, char,
|
||||
self->ob_size * itemsize);
|
||||
Py_Size(self) * itemsize);
|
||||
self->ob_item = item;
|
||||
self->allocated = self->ob_size;
|
||||
self->allocated = Py_Size(self);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
|
@ -1331,12 +1331,12 @@ Append items to array from list.");
|
|||
static PyObject *
|
||||
array_tolist(arrayobject *self, PyObject *unused)
|
||||
{
|
||||
PyObject *list = PyList_New(self->ob_size);
|
||||
PyObject *list = PyList_New(Py_Size(self));
|
||||
Py_ssize_t i;
|
||||
|
||||
if (list == NULL)
|
||||
return NULL;
|
||||
for (i = 0; i < self->ob_size; i++) {
|
||||
for (i = 0; i < Py_Size(self); i++) {
|
||||
PyObject *v = getarrayitem((PyObject *)self, i);
|
||||
if (v == NULL) {
|
||||
Py_DECREF(list);
|
||||
|
|
@ -1369,15 +1369,15 @@ array_fromstring(arrayobject *self, PyObject *args)
|
|||
n = n / itemsize;
|
||||
if (n > 0) {
|
||||
char *item = self->ob_item;
|
||||
PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize);
|
||||
PyMem_RESIZE(item, char, (Py_Size(self) + n) * itemsize);
|
||||
if (item == NULL) {
|
||||
PyErr_NoMemory();
|
||||
return NULL;
|
||||
}
|
||||
self->ob_item = item;
|
||||
self->ob_size += n;
|
||||
self->allocated = self->ob_size;
|
||||
memcpy(item + (self->ob_size - n) * itemsize,
|
||||
Py_Size(self) += n;
|
||||
self->allocated = Py_Size(self);
|
||||
memcpy(item + (Py_Size(self) - n) * itemsize,
|
||||
str, itemsize*n);
|
||||
}
|
||||
Py_INCREF(Py_None);
|
||||
|
|
@ -1395,7 +1395,7 @@ static PyObject *
|
|||
array_tostring(arrayobject *self, PyObject *unused)
|
||||
{
|
||||
return PyString_FromStringAndSize(self->ob_item,
|
||||
self->ob_size * self->ob_descr->itemsize);
|
||||
Py_Size(self) * self->ob_descr->itemsize);
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(tostring_doc,
|
||||
|
|
@ -1423,15 +1423,15 @@ array_fromunicode(arrayobject *self, PyObject *args)
|
|||
}
|
||||
if (n > 0) {
|
||||
Py_UNICODE *item = (Py_UNICODE *) self->ob_item;
|
||||
PyMem_RESIZE(item, Py_UNICODE, self->ob_size + n);
|
||||
PyMem_RESIZE(item, Py_UNICODE, Py_Size(self) + n);
|
||||
if (item == NULL) {
|
||||
PyErr_NoMemory();
|
||||
return NULL;
|
||||
}
|
||||
self->ob_item = (char *) item;
|
||||
self->ob_size += n;
|
||||
self->allocated = self->ob_size;
|
||||
memcpy(item + self->ob_size - n,
|
||||
Py_Size(self) += n;
|
||||
self->allocated = Py_Size(self);
|
||||
memcpy(item + Py_Size(self) - n,
|
||||
ustr, n * sizeof(Py_UNICODE));
|
||||
}
|
||||
|
||||
|
|
@ -1456,7 +1456,7 @@ array_tounicode(arrayobject *self, PyObject *unused)
|
|||
"tounicode() may only be called on type 'u' arrays");
|
||||
return NULL;
|
||||
}
|
||||
return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, self->ob_size);
|
||||
return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_Size(self));
|
||||
}
|
||||
|
||||
PyDoc_STRVAR(tounicode_doc,
|
||||
|
|
@ -1554,7 +1554,7 @@ array_repr(arrayobject *a)
|
|||
PyObject *s, *t, *v = NULL;
|
||||
Py_ssize_t len;
|
||||
|
||||
len = a->ob_size;
|
||||
len = Py_Size(a);
|
||||
typecode = a->ob_descr->typecode;
|
||||
if (len == 0) {
|
||||
PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode);
|
||||
|
|
@ -1588,7 +1588,7 @@ array_subscr(arrayobject* self, PyObject* item)
|
|||
return NULL;
|
||||
}
|
||||
if (i < 0)
|
||||
i += self->ob_size;
|
||||
i += Py_Size(self);
|
||||
return array_item(self, i);
|
||||
}
|
||||
else if (PySlice_Check(item)) {
|
||||
|
|
@ -1597,7 +1597,7 @@ array_subscr(arrayobject* self, PyObject* item)
|
|||
arrayobject* ar;
|
||||
int itemsize = self->ob_descr->itemsize;
|
||||
|
||||
if (PySlice_GetIndicesEx((PySliceObject*)item, self->ob_size,
|
||||
if (PySlice_GetIndicesEx((PySliceObject*)item, Py_Size(self),
|
||||
&start, &stop, &step, &slicelength) < 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -1636,14 +1636,14 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
|
|||
if (i==-1 && PyErr_Occurred())
|
||||
return -1;
|
||||
if (i < 0)
|
||||
i += self->ob_size;
|
||||
i += Py_Size(self);
|
||||
return array_ass_item(self, i, value);
|
||||
}
|
||||
else if (PySlice_Check(item)) {
|
||||
Py_ssize_t start, stop, step, slicelength;
|
||||
int itemsize = self->ob_descr->itemsize;
|
||||
|
||||
if (PySlice_GetIndicesEx((PySliceObject*)item, self->ob_size,
|
||||
if (PySlice_GetIndicesEx((PySliceObject*)item, Py_Size(self),
|
||||
&start, &stop, &step, &slicelength) < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
|
@ -1671,17 +1671,17 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
|
|||
self->ob_item + (cur + 1)*itemsize,
|
||||
(step - 1) * itemsize);
|
||||
}
|
||||
extra = self->ob_size - (cur + 1);
|
||||
extra = Py_Size(self) - (cur + 1);
|
||||
if (extra > 0) {
|
||||
memmove(self->ob_item + (cur - i)*itemsize,
|
||||
self->ob_item + (cur + 1)*itemsize,
|
||||
extra*itemsize);
|
||||
}
|
||||
|
||||
self->ob_size -= slicelength;
|
||||
Py_Size(self) -= slicelength;
|
||||
self->ob_item = (char *)PyMem_REALLOC(self->ob_item,
|
||||
itemsize*self->ob_size);
|
||||
self->allocated = self->ob_size;
|
||||
itemsize*Py_Size(self));
|
||||
self->allocated = Py_Size(self);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1693,16 +1693,16 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
|
|||
if (!array_Check(value)) {
|
||||
PyErr_Format(PyExc_TypeError,
|
||||
"must assign array (not \"%.200s\") to slice",
|
||||
value->ob_type->tp_name);
|
||||
Py_Type(value)->tp_name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
av = (arrayobject*)value;
|
||||
|
||||
if (av->ob_size != slicelength) {
|
||||
if (Py_Size(av) != slicelength) {
|
||||
PyErr_Format(PyExc_ValueError,
|
||||
"attempt to assign array of size %ld to extended slice of size %ld",
|
||||
/*XXX*/(long)av->ob_size, /*XXX*/(long)slicelength);
|
||||
/*XXX*/(long)Py_Size(av), /*XXX*/(long)slicelength);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
@ -1711,7 +1711,7 @@ array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
|
|||
|
||||
/* protect against a[::-1] = a */
|
||||
if (self == av) {
|
||||
value = array_slice(av, 0, av->ob_size);
|
||||
value = array_slice(av, 0, Py_Size(av));
|
||||
av = (arrayobject*)value;
|
||||
if (!av)
|
||||
return -1;
|
||||
|
|
@ -1758,7 +1758,7 @@ array_buffer_getreadbuf(arrayobject *self, Py_ssize_t index, const void **ptr)
|
|||
*ptr = (void *)self->ob_item;
|
||||
if (*ptr == NULL)
|
||||
*ptr = emptybuf;
|
||||
return self->ob_size*self->ob_descr->itemsize;
|
||||
return Py_Size(self)*self->ob_descr->itemsize;
|
||||
}
|
||||
|
||||
static Py_ssize_t
|
||||
|
|
@ -1772,14 +1772,14 @@ array_buffer_getwritebuf(arrayobject *self, Py_ssize_t index, const void **ptr)
|
|||
*ptr = (void *)self->ob_item;
|
||||
if (*ptr == NULL)
|
||||
*ptr = emptybuf;
|
||||
return self->ob_size*self->ob_descr->itemsize;
|
||||
return Py_Size(self)*self->ob_descr->itemsize;
|
||||
}
|
||||
|
||||
static Py_ssize_t
|
||||
array_buffer_getsegcount(arrayobject *self, Py_ssize_t *lenp)
|
||||
{
|
||||
if ( lenp )
|
||||
*lenp = self->ob_size*self->ob_descr->itemsize;
|
||||
*lenp = Py_Size(self)*self->ob_descr->itemsize;
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
|
@ -1888,9 +1888,9 @@ array_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|||
return NULL;
|
||||
}
|
||||
self->ob_item = item;
|
||||
self->ob_size = n / sizeof(Py_UNICODE);
|
||||
Py_Size(self) = n / sizeof(Py_UNICODE);
|
||||
memcpy(item, PyUnicode_AS_DATA(initial), n);
|
||||
self->allocated = self->ob_size;
|
||||
self->allocated = Py_Size(self);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
@ -1978,8 +1978,7 @@ itemsize -- the length in bytes of one array item\n\
|
|||
static PyObject *array_iter(arrayobject *ao);
|
||||
|
||||
static PyTypeObject Arraytype = {
|
||||
PyObject_HEAD_INIT(NULL)
|
||||
0,
|
||||
PyVarObject_HEAD_INIT(NULL, 0)
|
||||
"array.array",
|
||||
sizeof(arrayobject),
|
||||
0,
|
||||
|
|
@ -2060,7 +2059,7 @@ static PyObject *
|
|||
arrayiter_next(arrayiterobject *it)
|
||||
{
|
||||
assert(PyArrayIter_Check(it));
|
||||
if (it->index < it->ao->ob_size)
|
||||
if (it->index < Py_Size(it->ao))
|
||||
return (*it->getitem)(it->ao, it->index++);
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -2081,8 +2080,7 @@ arrayiter_traverse(arrayiterobject *it, visitproc visit, void *arg)
|
|||
}
|
||||
|
||||
static PyTypeObject PyArrayIter_Type = {
|
||||
PyObject_HEAD_INIT(NULL)
|
||||
0, /* ob_size */
|
||||
PyVarObject_HEAD_INIT(NULL, 0)
|
||||
"arrayiterator", /* tp_name */
|
||||
sizeof(arrayiterobject), /* tp_basicsize */
|
||||
0, /* tp_itemsize */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue