source: trunk/essentials/dev-lang/python/Objects/sliceobject.c@ 3408

/*
Written by Jim Hugunin and Chris Chase.

This includes both the singular ellipsis object and slice objects.

Guido, feel free to do whatever you want in the way of copyrights
for this file.
*/

/* 
Py_Ellipsis encodes the '...' rubber index token. It is similar to
the Py_NoneStruct in that there is no way to create other objects of
this type and there is exactly one in existence.
*/

#include "Python.h"
#include "structmember.h"

static PyObject *
ellipsis_repr(PyObject *op)
{
        return PyString_FromString("Ellipsis");
}

static PyTypeObject PyEllipsis_Type = {
        PyObject_HEAD_INIT(&PyType_Type)
        0,                              /* ob_size */
        "ellipsis",                     /* tp_name */
        0,                              /* tp_basicsize */
        0,                              /* tp_itemsize */
        0, /*never called*/             /* tp_dealloc */
        0,                              /* tp_print */
        0,                              /* tp_getattr */
        0,                              /* tp_setattr */
        0,                              /* tp_compare */
        ellipsis_repr,                  /* tp_repr */
        0,                              /* tp_as_number */
        0,                              /* tp_as_sequence */
        0,                              /* tp_as_mapping */
        0,                              /* tp_hash */
        0,                              /* tp_call */
        0,                              /* tp_str */
        PyObject_GenericGetAttr,        /* tp_getattro */
        0,                              /* tp_setattro */
        0,                              /* tp_as_buffer */
        Py_TPFLAGS_DEFAULT,             /* tp_flags */
};

PyObject _Py_EllipsisObject = {
        PyObject_HEAD_INIT(&PyEllipsis_Type)
};


/* Slice object implementation

   start, stop, and step are python objects with None indicating no
   index is present.
*/

PyObject *
PySlice_New(PyObject *start, PyObject *stop, PyObject *step)
{
        PySliceObject *obj = PyObject_New(PySliceObject, &PySlice_Type);

        if (obj == NULL)
                return NULL;

        if (step == NULL) step = Py_None;
        Py_INCREF(step);
        if (start == NULL) start = Py_None;
        Py_INCREF(start);
        if (stop == NULL) stop = Py_None;
        Py_INCREF(stop);

        obj->step = step;
        obj->start = start;
        obj->stop = stop;

        return (PyObject *) obj;
}

PyObject *
_PySlice_FromIndices(Py_ssize_t istart, Py_ssize_t istop)
{
        PyObject *start, *end, *slice;
        start = PyInt_FromSsize_t(istart);
        if (!start)
                return NULL;
        end = PyInt_FromSsize_t(istop);
        if (!end) {
                Py_DECREF(start);
                return NULL;
        }

        slice = PySlice_New(start, end, NULL);
        Py_DECREF(start);
        Py_DECREF(end);
        return slice;
}

int
PySlice_GetIndices(PySliceObject *r, Py_ssize_t length,
                   Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step)
{
        /* XXX support long ints */
        if (r->step == Py_None) {
                *step = 1;
        } else {
                if (!PyInt_Check(r->step) && !PyLong_Check(r->step)) return -1;
                *step = PyInt_AsSsize_t(r->step);
        }
        if (r->start == Py_None) {
                *start = *step < 0 ? length-1 : 0;
        } else {
                if (!PyInt_Check(r->start) && !PyLong_Check(r->step)) return -1;
                *start = PyInt_AsSsize_t(r->start);
                if (*start < 0) *start += length;
        }
        if (r->stop == Py_None) {
                *stop = *step < 0 ? -1 : length;