From f2d125bdada897e8ae1e6dd73f44d833bc0c7c15 Mon Sep 17 00:00:00 2001 From: Guido van Rossum Date: Tue, 30 Jul 1996 16:45:48 +0000 Subject: [PATCH] Added sliceobject.c --- Objects/Makefile.in | 7 +- Objects/sliceobject.c | 184 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 189 insertions(+), 2 deletions(-) create mode 100644 Objects/sliceobject.c diff --git a/Objects/Makefile.in b/Objects/Makefile.in index 2689f90684f..f5a2230ae67 100644 --- 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 index 00000000000..98222b6677b --- /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*/ +};