Added sliceobject.c

diff --git a/Objects/Makefile.in b/Objects/Makefile.in
index 2689f90684f8a4075d77aa12315a69d6fdd03a31..f5a2230ae6776d2bf28925745b1b5e9839087762 100644 (file)
--- a/Objects/Makefile.in
+++ b/Objects/Makefile.in
@@ -31,7 +31,8 @@ OBJS=         abstract.o accessobject.o \
                fileobject.o floatobject.o \
                frameobject.o funcobject.o intobject.o listobject.o \
                longobject.o mappingobject.o methodobject.o \
-               moduleobject.o object.o rangeobject.o stringobject.o \
+               moduleobject.o object.o rangeobject.o \
+               sliceobject.o stringobject.o \
                tupleobject.o typeobject.o
 
 SRCS=          abstract.c accessobject.c \
@@ -39,7 +40,8 @@ SRCS=         abstract.c accessobject.c \
                fileobject.c floatobject.c \
                frameobject.c funcobject.c intobject.c listobject.c \
                longobject.c mappingobject.c methodobject.c \
-               moduleobject.c object.c rangeobject.c stringobject.c \
+               moduleobject.c object.c rangeobject.c \
+               sliceobject.c stringobject.c \
                tupleobject.c typeobject.c
 
 LIB=           libObjects.a
@@ -87,6 +89,7 @@ methodobject.o: methodobject.c
 moduleobject.o: moduleobject.c
 object.o: object.c
 rangeobject.o: rangeobject.c
+sliceobject.o: sliceobject.c
 stringobject.o: stringobject.c
 tupleobject.o: tupleobject.c
 typeobject.o: typeobject.c

diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c
new file mode 100644 (file)
index 0000000..98222b6
--- /dev/null
+++ b/Objects/sliceobject.c
@@ -0,0 +1,184 @@
+/*
+Written by Jim Hugunin and Chris Chase.
+
+This includes both the singular ellipses object and slice objects.
+
+Guido, feel free to do whatever you want in the way of copyrights
+for this file.
+*/
+
+/* 
+Py_Ellipses 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"
+
+static PyObject *
+ellipses_repr(op)
+       PyObject *op;
+{
+       return PyString_FromString("...");
+}
+
+static PyTypeObject PyEllipses_Type = {
+       PyObject_HEAD_INIT(&PyType_Type)
+       0,
+       "ellipses",
+       0,
+       0,
+       0,              /*tp_dealloc*/ /*never called*/
+       0,              /*tp_print*/
+       0,              /*tp_getattr*/
+       0,              /*tp_setattr*/
+       0,              /*tp_compare*/
+       (reprfunc)ellipses_repr, /*tp_repr*/
+       0,              /*tp_as_number*/
+       0,              /*tp_as_sequence*/
+       0,              /*tp_as_mapping*/
+       0,              /*tp_hash */
+};
+
+PyObject _Py_EllipsesObject = {
+       PyObject_HEAD_INIT(&PyEllipses_Type)
+};
+
+
+/* Slice object implementation
+
+   start, stop, and step are python objects with None indicating no
+   index is present.
+*/
+
+PyObject *
+PySlice_New(start, stop, step)
+       PyObject *start;
+       PyObject *stop;
+       PyObject *step;
+{
+       PySliceObject *obj =
+               (PySliceObject *) PyObject_NEW(PySliceObject, &PySlice_Type);
+
+       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;
+}
+
+int
+PySlice_GetIndices(r, length, start, stop, step)
+       PySliceObject *r;
+       int length;
+       int *start;
+       int *stop;
+       int *step;
+{
+       if (r->step == Py_None) {
+               *step = 1;
+       } else {
+               if (!PyInt_Check(r->step)) return -1;
+               *step = PyInt_AsLong(r->step);
+       }
+       if (r->start == Py_None) {
+               *start = *step < 0 ? length-1 : 0;
+       } else {
+               if (!PyInt_Check(r->start)) return -1;
+               *start = PyInt_AsLong(r->start);
+               if (*start < 0) *start += length;
+       }
+       if (r->stop == Py_None) {
+               *stop = *step < 0 ? -1 : length;
+       } else {
+               if (!PyInt_Check(r->stop)) return -1;
+               *stop = PyInt_AsLong(r->stop);
+               if (*stop < 0) *stop += length;
+       }
+       if (*stop > length) return -1;
+       if (*start >= length) return -1;
+       if (*step == 0) return -1;
+       return 0;
+}
+
+static void
+slice_dealloc(r)
+       PySliceObject *r;
+{
+       Py_DECREF(r->step);
+       Py_DECREF(r->start);
+       Py_DECREF(r->stop);
+       PyMem_DEL(r);
+}
+
+static PyObject *
+slice_repr(r)
+       PySliceObject *r;
+{
+       PyObject *s, *comma;
+
+       s = PyString_FromString("slice(");
+       comma = PyString_FromString(", ");
+       PyString_ConcatAndDel(&s, PyObject_Repr(r->start));
+       PyString_Concat(&s, comma);
+       PyString_ConcatAndDel(&s, PyObject_Repr(r->stop));
+       PyString_Concat(&s, comma);
+       PyString_ConcatAndDel(&s, PyObject_Repr(r->step));
+       PyString_ConcatAndDel(&s, PyString_FromString(")"));
+       Py_DECREF(comma);
+       return s;
+}
+
+
+static PyObject *slice_getattr(self, name)
+       PySliceObject *self;
+       char *name;
+{
+       PyObject *ret;
+  
+       ret = NULL;
+       if (strcmp(name, "start") == 0) {
+               ret = self->start;
+       }
+       else if (strcmp(name, "stop") == 0) {
+               ret = self->stop;
+       }
+       else if (strcmp(name, "step") == 0) {
+               ret = self->step;
+       }
+       else if (strcmp(name, "__members__") == 0) {
+               return Py_BuildValue("[sss]",
+                                    "start", "stop", "step");
+       }
+       else {
+               PyErr_SetString(PyExc_AttributeError, name);
+               return NULL;
+       }
+       Py_INCREF(ret);
+       return ret;
+}
+
+
+PyTypeObject PySlice_Type = {
+       PyObject_HEAD_INIT(&PyType_Type)
+       0,                      /* Number of items for varobject */
+       "slice",                /* Name of this type */
+       sizeof(PySliceObject),  /* Basic object size */
+       0,                      /* Item size for varobject */
+       (destructor)slice_dealloc, /*tp_dealloc*/
+       0,                      /*tp_print*/
+       (getattrfunc)slice_getattr, /*tp_getattr*/
+       0,                      /*tp_setattr*/
+       0,                  /*tp_compare*/
+       (reprfunc)slice_repr, /*tp_repr*/
+       0,                      /*tp_as_number*/
+       0,              /*tp_as_sequence*/
+       0,                      /*tp_as_mapping*/
+};