source: trunk/essentials/dev-lang/python/Objects/tupleobject.c@ 3393

/* Tuple object implementation */

#include "Python.h"

/* Speed optimization to avoid frequent malloc/free of small tuples */
#ifndef MAXSAVESIZE
#define MAXSAVESIZE     20  /* Largest tuple to save on free list */
#endif
#ifndef MAXSAVEDTUPLES 
#define MAXSAVEDTUPLES  2000  /* Maximum number of tuples of each size to save */
#endif

#if MAXSAVESIZE > 0
/* Entries 1 up to MAXSAVESIZE are free lists, entry 0 is the empty
   tuple () of which at most one instance will be allocated.
*/
static PyTupleObject *free_tuples[MAXSAVESIZE];
static int num_free_tuples[MAXSAVESIZE];
#endif
#ifdef COUNT_ALLOCS
int fast_tuple_allocs;
int tuple_zero_allocs;
#endif

PyObject *
PyTuple_New(register Py_ssize_t size)
{
        register PyTupleObject *op;
        Py_ssize_t i;
        if (size < 0) {
                PyErr_BadInternalCall();
                return NULL;
        }
#if MAXSAVESIZE > 0
        if (size == 0 && free_tuples[0]) {
                op = free_tuples[0];
                Py_INCREF(op);
#ifdef COUNT_ALLOCS
                tuple_zero_allocs++;
#endif
                return (PyObject *) op;
        }
        if (size < MAXSAVESIZE && (op = free_tuples[size]) != NULL) {
                free_tuples[size] = (PyTupleObject *) op->ob_item[0];
                num_free_tuples[size]--;
#ifdef COUNT_ALLOCS
                fast_tuple_allocs++;
#endif
                /* Inline PyObject_InitVar */
#ifdef Py_TRACE_REFS
                op->ob_size = size;
                op->ob_type = &PyTuple_Type;
#endif
                _Py_NewReference((PyObject *)op);
        }
        else
#endif
        {
                Py_ssize_t nbytes = size * sizeof(PyObject *);
                /* Check for overflow */
                if (nbytes / sizeof(PyObject *) != (size_t)size ||
                    (nbytes += sizeof(PyTupleObject) - sizeof(PyObject *))
                    <= 0)
                {
                        return PyErr_NoMemory();
                }
                op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);
                if (op == NULL)
                        return NULL;
        }
        for (i=0; i < size; i++)
                op->ob_item[i] = NULL;
#if MAXSAVESIZE > 0
        if (size == 0) {
                free_tuples[0] = op;
                ++num_free_tuples[0];
                Py_INCREF(op);  /* extra INCREF so that this is never freed */
        }
#endif
        _PyObject_GC_TRACK(op);
        return (PyObject *) op;
}

Py_ssize_t
PyTuple_Size(register PyObject *op)
{
        if (!PyTuple_Check(op)) {
                PyErr_BadInternalCall();
                return -1;
        }
        else
                return ((PyTupleObject *)op)->ob_size;
}

PyObject *
PyTuple_GetItem(register PyObject *op, register Py_ssize_t i)
{
        if (!PyTuple_Check(op)) {
                PyErr_BadInternalCall();
                return NULL;
        }
        if (i < 0 || i >= ((PyTupleObject *)op) -> ob_size) {
                PyErr_SetString(PyExc_IndexError, "tuple index out of range");
                return NULL;
        }
        return ((PyTupleObject *)op) -> ob_item[i];
}

int
PyTuple_SetItem(register PyObject *op, register Py_ssize_t i, PyObject *newitem)
{
        register PyObject *olditem;
        register PyObject **p;
        if (!PyTuple_Check(op) || op->ob_refcnt != 1) {
                Py_XDECREF(newitem);
                PyErr_BadInternalCall();
                return -1;
        }
        if (i < 0 || i >= ((PyTupleObject *)op) -> ob_size) {
                Py_XDECREF(newitem);
                PyErr_SetString(PyExc_IndexError,
                                "tuple assignment index out of range");
                return -1;
        }
        p = ((PyTupleObject *)op) -> ob_item + i;
        olditem = *p;
        *p = newitem;
        Py_XDECREF(olditem);
        return 0;
}

PyObject *
PyTuple_Pack(Py_ssize_t n, ...)
{
        Py_ssize_t i;
        PyObject *o;
        PyObject *result;
        PyObject **items;
        va_list vargs;

        va_start(vargs, n);
        result = PyTuple_New(n);
        if (result == NULL)
                return NULL;
        items = ((PyTupleObject *)result)->ob_item;
        for (i = 0; i < n; i++) {
                o = va_arg(vargs, PyObject *);
                Py_INCREF(o);
                items[i] = o;
        }
        va_end(vargs);
        return result;
}


/* Methods */

static void
tupledealloc(register PyTupleObject *op)
{
        register Py_ssize_t i;
        register Py_ssize_t len =  op->ob_size;
        PyObject_GC_UnTrack(op);
        Py_TRASHCAN_SAFE_BEGIN(op)
        if (len > 0) {
                i = len;
                while (--i >= 0)
                        Py_XDECREF(op->ob_item[i]);
#if MAXSAVESIZE > 0
                if (len < MAXSAVESIZE &&
                    num_free_tuples[len] < MAXSAVEDTUPLES &&
                    op->ob_type == &PyTuple_Type)
                {
                        op->ob_item[0] = (PyObject *) free_tuples[len];
                        num_free_tuples[len]++;
                        free_tuples[len] = op;
                        goto done; /* return */
                }
#endif
        }
        op->ob_type->tp_free((PyObject *)op);
done:
        Py_TRASHCAN_SAFE_END(op)
}

static int
tupleprint(PyTupleObject *op, FILE *fp, int flags)
{
        Py_ssize_t i;
        fprintf(fp, "(");
        for (i = 0; i < op->ob_size; i++) {
                if (i > 0)
                        fprintf(fp, ", ");
                if (PyObject_Print(op->ob_item[i], fp, 0) != 0)
                        return -1;
        }
        if (op->ob_size == 1)
                fprintf(fp, ",");
        fprintf(fp, ")");
        return 0;
}

static PyObject *
tuplerepr(PyTupleObject *v)