diff options
author | Christian Heimes <christian@cheimes.de> | 2007-12-19 02:45:37 +0000 |
---|---|---|
committer | Christian Heimes <christian@cheimes.de> | 2007-12-19 02:45:37 +0000 |
commit | d87a72a1e9d2f905be78a5f0b6f0efd2c71aecd4 (patch) | |
tree | 19dda31d5adcf70440e5aa2565efa9d1701a2f21 /Objects/listobject.c | |
parent | 386ef4a4352cfcfdc9f666f2379cfe566ad8b4b7 (diff) | |
download | cpython-d87a72a1e9d2f905be78a5f0b6f0efd2c71aecd4.tar.gz |
#1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT.
Diffstat (limited to 'Objects/listobject.c')
-rw-r--r-- | Objects/listobject.c | 164 |
1 files changed, 82 insertions, 82 deletions
diff --git a/Objects/listobject.c b/Objects/listobject.c index 9fbc463602..b62bba543b 100644 --- a/Objects/listobject.c +++ b/Objects/listobject.c @@ -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); - Py_Size(self) = 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; - Py_Size(self) = 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); } - Py_Size(op) = 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 Py_Size(op); + 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 >= Py_Size(op)) { + if (i < 0 || i >= Py_SIZE(op)) { if (indexerr == NULL) indexerr = PyUnicode_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 >= Py_Size(op)) { + 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 = Py_Size(self); + 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 = Py_Size(op); + 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 - Py_Type(op)->tp_free((PyObject *)op); + Py_TYPE(op)->tp_free((PyObject *)op); Py_TRASHCAN_SAFE_END(op) } @@ -284,7 +284,7 @@ list_repr(PyListObject *v) return i > 0 ? PyUnicode_FromString("[...]") : NULL; } - if (Py_Size(v) == 0) { + if (Py_SIZE(v) == 0) { result = PyUnicode_FromString("[]"); goto Done; } @@ -295,7 +295,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 < Py_Size(v); ++i) { + for (i = 0; i < Py_SIZE(v); ++i) { int status; if (Py_EnterRecursiveCall(" while getting the repr of a list")) goto Done; @@ -345,7 +345,7 @@ Done: static Py_ssize_t list_length(PyListObject *a) { - return Py_Size(a); + return Py_SIZE(a); } static int @@ -354,7 +354,7 @@ list_contains(PyListObject *a, PyObject *el) Py_ssize_t i; int cmp; - for (i = 0, cmp = 0 ; cmp == 0 && i < Py_Size(a); ++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; @@ -363,7 +363,7 @@ list_contains(PyListObject *a, PyObject *el) static PyObject * list_item(PyListObject *a, Py_ssize_t i) { - if (i < 0 || i >= Py_Size(a)) { + if (i < 0 || i >= Py_SIZE(a)) { if (indexerr == NULL) indexerr = PyUnicode_FromString( "list index out of range"); @@ -382,12 +382,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 > Py_Size(a)) - ilow = Py_Size(a); + else if (ilow > Py_SIZE(a)) + ilow = Py_SIZE(a); if (ihigh < ilow) ihigh = ilow; - else if (ihigh > Py_Size(a)) - ihigh = Py_Size(a); + else if (ihigh > Py_SIZE(a)) + ihigh = Py_SIZE(a); len = ihigh - ilow; np = (PyListObject *) PyList_New(len); if (np == NULL) @@ -427,7 +427,7 @@ list_concat(PyListObject *a, PyObject *bb) return NULL; } #define b ((PyListObject *)bb) - size = Py_Size(a) + Py_Size(b); + size = Py_SIZE(a) + Py_SIZE(b); if (size < 0) return PyErr_NoMemory(); np = (PyListObject *) PyList_New(size); @@ -436,14 +436,14 @@ list_concat(PyListObject *a, PyObject *bb) } src = a->ob_item; dest = np->ob_item; - for (i = 0; i < Py_Size(a); 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 + Py_Size(a); - for (i = 0; i < Py_Size(b); 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; @@ -462,8 +462,8 @@ list_repeat(PyListObject *a, Py_ssize_t n) PyObject *elem; if (n < 0) n = 0; - size = Py_Size(a) * n; - if (n && size/n != Py_Size(a)) + size = Py_SIZE(a) * n; + if (n && size/n != Py_SIZE(a)) return PyErr_NoMemory(); if (size == 0) return PyList_New(0); @@ -472,7 +472,7 @@ list_repeat(PyListObject *a, Py_ssize_t n) return NULL; items = np->ob_item; - if (Py_Size(a) == 1) { + if (Py_SIZE(a) == 1) { elem = a->ob_item[0]; for (i = 0; i < n; i++) { items[i] = elem; @@ -483,7 +483,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 < Py_Size(a); j++) { + for (j = 0; j < Py_SIZE(a); j++) { *p = items[j]; Py_INCREF(*p); p++; @@ -500,8 +500,8 @@ list_clear(PyListObject *a) if (item != NULL) { /* Because XDECREF can recursively invoke operations on this list, we make it empty first. */ - i = Py_Size(a); - Py_Size(a) = 0; + i = Py_SIZE(a); + Py_SIZE(a) = 0; a->ob_item = NULL; a->allocated = 0; while (--i >= 0) { @@ -547,7 +547,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, Py_Size(b)); + v = list_slice(b, 0, Py_SIZE(b)); if (v == NULL) return result; result = list_ass_slice(a, ilow, ihigh, v); @@ -562,18 +562,18 @@ list_ass_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v) } if (ilow < 0) ilow = 0; - else if (ilow > Py_Size(a)) - ilow = Py_Size(a); + else if (ilow > Py_SIZE(a)) + ilow = Py_SIZE(a); if (ihigh < ilow) ihigh = ilow; - else if (ihigh > Py_Size(a)) - ihigh = Py_Size(a); + else if (ihigh > Py_SIZE(a)) + ihigh = Py_SIZE(a); norig = ihigh - ilow; assert(norig >= 0); d = n - norig; - if (Py_Size(a) + d == 0) { + if (Py_SIZE(a) + d == 0) { Py_XDECREF(v_as_SF); return list_clear(a); } @@ -591,12 +591,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], - (Py_Size(a) - ihigh)*sizeof(PyObject *)); - list_resize(a, Py_Size(a) + 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 = Py_Size(a); + k = Py_SIZE(a); if (list_resize(a, k+d) < 0) goto Error; item = a->ob_item; @@ -671,7 +671,7 @@ static int list_ass_item(PyListObject *a, Py_ssize_t i, PyObject *v) { PyObject *old_value; - if (i < 0 || i >= Py_Size(a)) { + if (i < 0 || i >= Py_SIZE(a)) { PyErr_SetString(PyExc_IndexError, "list assignment index out of range"); return -1; @@ -730,7 +730,7 @@ listextend(PyListObject *self, PyObject *b) Py_DECREF(b); Py_RETURN_NONE; } - m = Py_Size(self); + m = Py_SIZE(self); if (list_resize(self, m + n) == -1) { Py_DECREF(b); return NULL; @@ -759,14 +759,14 @@ listextend(PyListObject *self, PyObject *b) /* Guess a result list size. */ n = _PyObject_LengthHint(b, 8); - m = Py_Size(self); + 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. */ - Py_Size(self) = 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 @@ -785,10 +785,10 @@ listextend(PyListObject *self, PyObject *b) } break; } - if (Py_Size(self) < self->allocated) { + if (Py_SIZE(self) < self->allocated) { /* steals ref */ - PyList_SET_ITEM(self, Py_Size(self), item); - ++Py_Size(self); + PyList_SET_ITEM(self, Py_SIZE(self), item); + ++Py_SIZE(self); } else { int status = app1(self, item); @@ -799,8 +799,8 @@ listextend(PyListObject *self, PyObject *b) } /* Cut back result list if initial guess was too large. */ - if (Py_Size(self) < self->allocated) - list_resize(self, Py_Size(self)); /* 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; @@ -839,20 +839,20 @@ listpop(PyListObject *self, PyObject *args) if (!PyArg_ParseTuple(args, "|n:pop", &i)) return NULL; - if (Py_Size(self) == 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 += Py_Size(self); - if (i < 0 || i >= Py_Size(self)) { + 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 == Py_Size(self) - 1) { - status = list_resize(self, Py_Size(self) - 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 */ } @@ -2009,10 +2009,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 = Py_Size(self); + saved_ob_size = Py_SIZE(self); saved_ob_item = self->ob_item; saved_allocated = self->allocated; - Py_Size(self) = 0; + Py_SIZE(self) = 0; self->ob_item = NULL; self->allocated = -1; /* any operation will reset it to >= 0 */ @@ -2118,8 +2118,8 @@ fail: dsu_fail: final_ob_item = self->ob_item; - i = Py_Size(self); - Py_Size(self) = 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) { @@ -2154,8 +2154,8 @@ PyList_Sort(PyObject *v) static PyObject * listreverse(PyListObject *self) { - if (Py_Size(self) > 1) - reverse_slice(self->ob_item, self->ob_item + Py_Size(self)); + if (Py_SIZE(self) > 1) + reverse_slice(self->ob_item, self->ob_item + Py_SIZE(self)); Py_RETURN_NONE; } @@ -2168,8 +2168,8 @@ PyList_Reverse(PyObject *v) PyErr_BadInternalCall(); return -1; } - if (Py_Size(self) > 1) - reverse_slice(self->ob_item, self->ob_item + Py_Size(self)); + if (Py_SIZE(self) > 1) + reverse_slice(self->ob_item, self->ob_item + Py_SIZE(self)); return 0; } @@ -2183,7 +2183,7 @@ PyList_AsTuple(PyObject *v) PyErr_BadInternalCall(); return NULL; } - n = Py_Size(v); + n = Py_SIZE(v); w = PyTuple_New(n); if (w == NULL) return NULL; @@ -2201,7 +2201,7 @@ PyList_AsTuple(PyObject *v) static PyObject * listindex(PyListObject *self, PyObject *args) { - Py_ssize_t i, start=0, stop=Py_Size(self); + Py_ssize_t i, start=0, stop=Py_SIZE(self); PyObject *v; if (!PyArg_ParseTuple(args, "O|O&O&:index", &v, @@ -2209,16 +2209,16 @@ listindex(PyListObject *self, PyObject *args) _PyEval_SliceIndex, &stop)) return NULL; if (start < 0) { - start += Py_Size(self); + start += Py_SIZE(self); if (start < 0) start = 0; } if (stop < 0) { - stop += Py_Size(self); + stop += Py_SIZE(self); if (stop < 0) stop = 0; } - for (i = start; i < stop && i < Py_Size(self); 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 PyLong_FromSsize_t(i); @@ -2235,7 +2235,7 @@ listcount(PyListObject *self, PyObject *v) Py_ssize_t count = 0; Py_ssize_t i; - for (i = 0; i < Py_Size(self); i++) { + for (i = 0; i < Py_SIZE(self); i++) { int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ); if (cmp > 0) count++; @@ -2250,7 +2250,7 @@ listremove(PyListObject *self, PyObject *v) { Py_ssize_t i; - for (i = 0; i < Py_Size(self); 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, @@ -2270,7 +2270,7 @@ list_traverse(PyListObject *o, visitproc visit, void *arg) { Py_ssize_t i; - for (i = Py_Size(o); --i >= 0; ) + for (i = Py_SIZE(o); --i >= 0; ) Py_VISIT(o->ob_item[i]); return 0; } @@ -2289,7 +2289,7 @@ list_richcompare(PyObject *v, PyObject *w, int op) vl = (PyListObject *)v; wl = (PyListObject *)w; - if (Py_Size(vl) != Py_Size(wl) && (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) @@ -2301,7 +2301,7 @@ list_richcompare(PyObject *v, PyObject *w, int op) } /* Search for the first index where items are different */ - for (i = 0; i < Py_Size(vl) && i < Py_Size(wl); 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) @@ -2310,10 +2310,10 @@ list_richcompare(PyObject *v, PyObject *w, int op) break; } - if (i >= Py_Size(vl) || i >= Py_Size(wl)) { + if (i >= Py_SIZE(vl) || i >= Py_SIZE(wl)) { /* No more items to compare -- compare sizes */ - Py_ssize_t vs = Py_Size(vl); - Py_ssize_t ws = Py_Size(wl); + Py_ssize_t vs = Py_SIZE(vl); + Py_ssize_t ws = Py_SIZE(wl); int cmp; PyObject *res; switch (op) { @@ -2357,8 +2357,8 @@ list_init(PyListObject *self, PyObject *args, PyObject *kw) return -1; /* Verify list invariants established by PyType_GenericAlloc() */ - assert(0 <= Py_Size(self)); - assert(Py_Size(self) <= 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); @@ -2454,7 +2454,7 @@ list_subscript(PyListObject* self, PyObject* item) PyObject* it; PyObject **src, **dest; - if (PySlice_GetIndicesEx((PySliceObject*)item, Py_Size(self), + if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self), &start, &stop, &step, &slicelength) < 0) { return NULL; } @@ -2503,7 +2503,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, Py_Size(self), + if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self), &start, &stop, &step, &slicelength) < 0) { return -1; } @@ -2551,8 +2551,8 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value) garbage[i] = PyList_GET_ITEM(self, cur); - if (cur + step >= Py_Size(self)) { - lim = Py_Size(self) - cur - 1; + if (cur + step >= Py_SIZE(self)) { + lim = Py_SIZE(self) - cur - 1; } memmove(self->ob_item + cur - i, @@ -2560,15 +2560,15 @@ list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value) lim * sizeof(PyObject *)); } cur = start + slicelength*step; - if (cur < Py_Size(self)) { + if (cur < Py_SIZE(self)) { memmove(self->ob_item + cur - slicelength, self->ob_item + cur, - (Py_Size(self) - cur) * + (Py_SIZE(self) - cur) * sizeof(PyObject *)); } - Py_Size(self) -= slicelength; - list_resize(self, Py_Size(self)); + Py_SIZE(self) -= slicelength; + list_resize(self, Py_SIZE(self)); for (i = 0; i < slicelength; i++) { Py_DECREF(garbage[i]); |