Added sliceobject.c

1 files changed, 184 insertions, 0 deletions

diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c
new file mode 100644
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*/
+};