Quickly renamed the last directory.
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index fd53c30..7dc4dc8 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -31,7 +31,7 @@
/* Tuple object implementation */
-#include "allobjects.h"
+#include "Python.h"
#ifndef MAXSAVESIZE
#define MAXSAVESIZE 20
@@ -41,109 +41,112 @@
/* Entries 1 upto MAXSAVESIZE are free lists, entry 0 is the empty
tuple () of which at most one instance will be allocated.
*/
-static tupleobject *free_tuples[MAXSAVESIZE];
+static PyTupleObject *free_tuples[MAXSAVESIZE];
#endif
#ifdef COUNT_ALLOCS
int fast_tuple_allocs;
int tuple_zero_allocs;
#endif
-object *
-newtupleobject(size)
+PyObject *
+PyTuple_New(size)
register int size;
{
register int i;
- register tupleobject *op;
+ register PyTupleObject *op;
if (size < 0) {
- err_badcall();
+ PyErr_BadInternalCall();
return NULL;
}
#if MAXSAVESIZE > 0
if (size == 0 && free_tuples[0]) {
op = free_tuples[0];
- INCREF(op);
+ Py_INCREF(op);
#ifdef COUNT_ALLOCS
tuple_zero_allocs++;
#endif
- return (object *) op;
+ return (PyObject *) op;
}
- if (0 < size && size < MAXSAVESIZE && (op = free_tuples[size]) != NULL) {
- free_tuples[size] = (tupleobject *) op->ob_item[0];
+ if (0 < size && size < MAXSAVESIZE &&
+ (op = free_tuples[size]) != NULL)
+ {
+ free_tuples[size] = (PyTupleObject *) op->ob_item[0];
#ifdef COUNT_ALLOCS
fast_tuple_allocs++;
#endif
} else
#endif
{
- op = (tupleobject *)
- malloc(sizeof(tupleobject) + size * sizeof(object *));
+ op = (PyTupleObject *) malloc(
+ sizeof(PyTupleObject) + size * sizeof(PyObject *));
if (op == NULL)
- return err_nomem();
+ return PyErr_NoMemory();
}
- op->ob_type = &Tupletype;
+ op->ob_type = &PyTuple_Type;
op->ob_size = size;
for (i = 0; i < size; i++)
op->ob_item[i] = NULL;
- NEWREF(op);
+ _Py_NewReference(op);
#if MAXSAVESIZE > 0
if (size == 0) {
free_tuples[0] = op;
- INCREF(op); /* extra INCREF so that this is never freed */
+ Py_INCREF(op); /* extra INCREF so that this is never freed */
}
#endif
- return (object *) op;
+ return (PyObject *) op;
}
int
-gettuplesize(op)
- register object *op;
+PyTuple_Size(op)
+ register PyObject *op;
{
- if (!is_tupleobject(op)) {
- err_badcall();
+ if (!PyTuple_Check(op)) {
+ PyErr_BadInternalCall();
return -1;
}
else
- return ((tupleobject *)op)->ob_size;
+ return ((PyTupleObject *)op)->ob_size;
}
-object *
-gettupleitem(op, i)
- register object *op;
+PyObject *
+PyTuple_GetItem(op, i)
+ register PyObject *op;
register int i;
{
- if (!is_tupleobject(op)) {
- err_badcall();
+ if (!PyTuple_Check(op)) {
+ PyErr_BadInternalCall();
return NULL;
}
- if (i < 0 || i >= ((tupleobject *)op) -> ob_size) {
- err_setstr(IndexError, "tuple index out of range");
+ if (i < 0 || i >= ((PyTupleObject *)op) -> ob_size) {
+ PyErr_SetString(PyExc_IndexError, "tuple index out of range");
return NULL;
}
- return ((tupleobject *)op) -> ob_item[i];
+ return ((PyTupleObject *)op) -> ob_item[i];
}
int
-settupleitem(op, i, newitem)
- register object *op;
+PyTuple_SetItem(op, i, newitem)
+ register PyObject *op;
register int i;
- object *newitem;
+ PyObject *newitem;
{
- register object *olditem;
- register object **p;
- if (!is_tupleobject(op)) {
- XDECREF(newitem);
- err_badcall();
+ register PyObject *olditem;
+ register PyObject **p;
+ if (!PyTuple_Check(op)) {
+ Py_XDECREF(newitem);
+ PyErr_BadInternalCall();
return -1;
}
- if (i < 0 || i >= ((tupleobject *)op) -> ob_size) {
- XDECREF(newitem);
- err_setstr(IndexError, "tuple assignment index out of range");
+ if (i < 0 || i >= ((PyTupleObject *)op) -> ob_size) {
+ Py_XDECREF(newitem);
+ PyErr_SetString(PyExc_IndexError,
+ "tuple assignment index out of range");
return -1;
}
- p = ((tupleobject *)op) -> ob_item + i;
+ p = ((PyTupleObject *)op) -> ob_item + i;
olditem = *p;
*p = newitem;
- XDECREF(olditem);
+ Py_XDECREF(olditem);
return 0;
}
@@ -151,14 +154,14 @@
static void
tupledealloc(op)
- register tupleobject *op;
+ register PyTupleObject *op;
{
register int i;
for (i = 0; i < op->ob_size; i++)
- XDECREF(op->ob_item[i]);
+ Py_XDECREF(op->ob_item[i]);
#if MAXSAVESIZE > 0
if (0 < op->ob_size && op->ob_size < MAXSAVESIZE) {
- op->ob_item[0] = (object *) free_tuples[op->ob_size];
+ op->ob_item[0] = (PyObject *) free_tuples[op->ob_size];
free_tuples[op->ob_size] = op;
} else
#endif
@@ -167,7 +170,7 @@
static int
tupleprint(op, fp, flags)
- tupleobject *op;
+ PyTupleObject *op;
FILE *fp;
int flags;
{
@@ -176,7 +179,7 @@
for (i = 0; i < op->ob_size; i++) {
if (i > 0)
fprintf(fp, ", ");
- if (printobject(op->ob_item[i], fp, 0) != 0)
+ if (PyObject_Print(op->ob_item[i], fp, 0) != 0)
return -1;
}
if (op->ob_size == 1)
@@ -185,35 +188,35 @@
return 0;
}
-static object *
+static PyObject *
tuplerepr(v)
- tupleobject *v;
+ PyTupleObject *v;
{
- object *s, *comma;
+ PyObject *s, *comma;
int i;
- s = newstringobject("(");
- comma = newstringobject(", ");
+ s = PyString_FromString("(");
+ comma = PyString_FromString(", ");
for (i = 0; i < v->ob_size && s != NULL; i++) {
if (i > 0)
- joinstring(&s, comma);
- joinstring_decref(&s, reprobject(v->ob_item[i]));
+ PyString_Concat(&s, comma);
+ PyString_ConcatAndDel(&s, PyObject_Repr(v->ob_item[i]));
}
- DECREF(comma);
+ Py_DECREF(comma);
if (v->ob_size == 1)
- joinstring_decref(&s, newstringobject(","));
- joinstring_decref(&s, newstringobject(")"));
+ PyString_ConcatAndDel(&s, PyString_FromString(","));
+ PyString_ConcatAndDel(&s, PyString_FromString(")"));
return s;
}
static int
tuplecompare(v, w)
- register tupleobject *v, *w;
+ register PyTupleObject *v, *w;
{
register int len =
(v->ob_size < w->ob_size) ? v->ob_size : w->ob_size;
register int i;
for (i = 0; i < len; i++) {
- int cmp = cmpobject(v->ob_item[i], w->ob_item[i]);
+ int cmp = PyObject_Compare(v->ob_item[i], w->ob_item[i]);
if (cmp != 0)
return cmp;
}
@@ -222,15 +225,15 @@
static long
tuplehash(v)
- tupleobject *v;
+ PyTupleObject *v;
{
register long x, y;
register int len = v->ob_size;
- register object **p;
+ register PyObject **p;
x = 0x345678L;
p = v->ob_item;
while (--len >= 0) {
- y = hashobject(*p++);
+ y = PyObject_Hash(*p++);
if (y == -1)
return -1;
x = (1000003*x) ^ y;
@@ -243,30 +246,30 @@
static int
tuplelength(a)
- tupleobject *a;
+ PyTupleObject *a;
{
return a->ob_size;
}
-static object *
+static PyObject *
tupleitem(a, i)
- register tupleobject *a;
+ register PyTupleObject *a;
register int i;
{
if (i < 0 || i >= a->ob_size) {
- err_setstr(IndexError, "tuple index out of range");
+ PyErr_SetString(PyExc_IndexError, "tuple index out of range");
return NULL;
}
- INCREF(a->ob_item[i]);
+ Py_INCREF(a->ob_item[i]);
return a->ob_item[i];
}
-static object *
+static PyObject *
tupleslice(a, ilow, ihigh)
- register tupleobject *a;
+ register PyTupleObject *a;
register int ilow, ihigh;
{
- register tupleobject *np;
+ register PyTupleObject *np;
register int i;
if (ilow < 0)
ilow = 0;
@@ -276,97 +279,97 @@
ihigh = ilow;
if (ilow == 0 && ihigh == a->ob_size) {
/* XXX can only do this if tuples are immutable! */
- INCREF(a);
- return (object *)a;
+ Py_INCREF(a);
+ return (PyObject *)a;
}
- np = (tupleobject *)newtupleobject(ihigh - ilow);
+ np = (PyTupleObject *)PyTuple_New(ihigh - ilow);
if (np == NULL)
return NULL;
for (i = ilow; i < ihigh; i++) {
- object *v = a->ob_item[i];
- INCREF(v);
+ PyObject *v = a->ob_item[i];
+ Py_INCREF(v);
np->ob_item[i - ilow] = v;
}
- return (object *)np;
+ return (PyObject *)np;
}
-object *
-gettupleslice(op, i, j)
- object *op;
+PyObject *
+PyTuple_GetSlice(op, i, j)
+ PyObject *op;
int i, j;
{
- if (op == NULL || !is_tupleobject(op)) {
- err_badcall();
+ if (op == NULL || !PyTuple_Check(op)) {
+ PyErr_BadInternalCall();
return NULL;
}
- return tupleslice((tupleobject *)op, i, j);
+ return tupleslice((PyTupleObject *)op, i, j);
}
-static object *
+static PyObject *
tupleconcat(a, bb)
- register tupleobject *a;
- register object *bb;
+ register PyTupleObject *a;
+ register PyObject *bb;
{
register int size;
register int i;
- tupleobject *np;
- if (!is_tupleobject(bb)) {
- err_badarg();
+ PyTupleObject *np;
+ if (!PyTuple_Check(bb)) {
+ PyErr_BadArgument();
return NULL;
}
-#define b ((tupleobject *)bb)
+#define b ((PyTupleObject *)bb)
size = a->ob_size + b->ob_size;
- np = (tupleobject *) newtupleobject(size);
+ np = (PyTupleObject *) PyTuple_New(size);
if (np == NULL) {
return NULL;
}
for (i = 0; i < a->ob_size; i++) {
- object *v = a->ob_item[i];
- INCREF(v);
+ PyObject *v = a->ob_item[i];
+ Py_INCREF(v);
np->ob_item[i] = v;
}
for (i = 0; i < b->ob_size; i++) {
- object *v = b->ob_item[i];
- INCREF(v);
+ PyObject *v = b->ob_item[i];
+ Py_INCREF(v);
np->ob_item[i + a->ob_size] = v;
}
- return (object *)np;
+ return (PyObject *)np;
#undef b
}
-static object *
+static PyObject *
tuplerepeat(a, n)
- tupleobject *a;
+ PyTupleObject *a;
int n;
{
int i, j;
int size;
- tupleobject *np;
- object **p;
+ PyTupleObject *np;
+ PyObject **p;
if (n < 0)
n = 0;
if (a->ob_size*n == a->ob_size) {
/* Since tuples are immutable, we can return a shared
copy in this case */
- INCREF(a);
- return (object *)a;
+ Py_INCREF(a);
+ return (PyObject *)a;
}
size = a->ob_size * n;
- np = (tupleobject *) newtupleobject(size);
+ np = (PyTupleObject *) PyTuple_New(size);
if (np == NULL)
return NULL;
p = np->ob_item;
for (i = 0; i < n; i++) {
for (j = 0; j < a->ob_size; j++) {
*p = a->ob_item[j];
- INCREF(*p);
+ Py_INCREF(*p);
p++;
}
}
- return (object *) np;
+ return (PyObject *) np;
}
-static sequence_methods tuple_as_sequence = {
+static PySequenceMethods tuple_as_sequence = {
(inquiry)tuplelength, /*sq_length*/
(binaryfunc)tupleconcat, /*sq_concat*/
(intargfunc)tuplerepeat, /*sq_repeat*/
@@ -376,12 +379,12 @@
0, /*sq_ass_slice*/
};
-typeobject Tupletype = {
- OB_HEAD_INIT(&Typetype)
+PyTypeObject PyTuple_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
0,
"tuple",
- sizeof(tupleobject) - sizeof(object *),
- sizeof(object *),
+ sizeof(PyTupleObject) - sizeof(PyObject *),
+ sizeof(PyObject *),
(destructor)tupledealloc, /*tp_dealloc*/
(printfunc)tupleprint, /*tp_print*/
0, /*tp_getattr*/
@@ -404,21 +407,21 @@
front, otherwise it will grow or shrink at the end. */
int
-resizetuple(pv, newsize, last_is_sticky)
- object **pv;
+_PyTuple_Resize(pv, newsize, last_is_sticky)
+ PyObject **pv;
int newsize;
int last_is_sticky;
{
- register tupleobject *v;
- register tupleobject *sv;
+ register PyTupleObject *v;
+ register PyTupleObject *sv;
int i;
int sizediff;
- v = (tupleobject *) *pv;
- if (v == NULL || !is_tupleobject(v) || v->ob_refcnt != 1) {
+ v = (PyTupleObject *) *pv;
+ if (v == NULL || !PyTuple_Check(v) || v->ob_refcnt != 1) {
*pv = 0;
- DECREF(v);
- err_badcall();
+ Py_DECREF(v);
+ PyErr_BadInternalCall();
return -1;
}
sizediff = newsize - v->ob_size;
@@ -428,29 +431,30 @@
#ifdef Py_REF_DEBUG
--_Py_RefTotal;
#endif
- UNREF(v);
+ _Py_ForgetReference(v);
if (last_is_sticky && sizediff < 0) {
- /* shrinking: move entries to the front and zero moved entries */
+ /* shrinking:
+ move entries to the front and zero moved entries */
for (i = 0; i < newsize; i++) {
- XDECREF(v->ob_item[i]);
+ Py_XDECREF(v->ob_item[i]);
v->ob_item[i] = v->ob_item[i - sizediff];
v->ob_item[i - sizediff] = NULL;
}
}
for (i = newsize; i < v->ob_size; i++) {
- XDECREF(v->ob_item[i]);
+ Py_XDECREF(v->ob_item[i]);
v->ob_item[i] = NULL;
}
- sv = (tupleobject *)
+ sv = (PyTupleObject *)
realloc((char *)v,
- sizeof(tupleobject) + newsize * sizeof(object *));
- *pv = (object *) sv;
+ sizeof(PyTupleObject) + newsize * sizeof(PyObject *));
+ *pv = (PyObject *) sv;
if (sv == NULL) {
- DEL(v);
- err_nomem();
+ PyMem_DEL(v);
+ PyErr_NoMemory();
return -1;
}
- NEWREF(sv);
+ _Py_NewReference(sv);
for (i = sv->ob_size; i < newsize; i++)
sv->ob_item[i] = NULL;
if (last_is_sticky && sizediff > 0) {