Objects/sliceobject.c

   1 /*
   2 Written by Jim Hugunin and Chris Chase.
   3
   4 This includes both the singular ellipsis object and slice objects.
   5
   6 Guido, feel free to do whatever you want in the way of copyrights
   7 for this file.
   8 */
   9
  10 /*
  11 Py_Ellipsis encodes the '...' rubber index token. It is similar to
  12 the Py_NoneStruct in that there is no way to create other objects of
  13 this type and there is exactly one in existence.
  14 */
  15
  16 #include "Python.h"
  17 #include "structmember.h"
  18
  19 static PyObject *
  20 ellipsis_repr(PyObject *op)
  21 {
  22         return PyString_FromString("Ellipsis");
  23 }
  24
  25 static PyTypeObject PyEllipsis_Type = {
  26         PyObject_HEAD_INIT(&PyType_Type)
  27         0,                                      /* ob_size */
  28         "ellipsis",                             /* tp_name */
  29         0,                                      /* tp_basicsize */
  30         0,                                      /* tp_itemsize */
  31         0, /*never called*/                     /* tp_dealloc */
  32         0,                                      /* tp_print */
  33         0,                                      /* tp_getattr */
  34         0,                                      /* tp_setattr */
  35         0,                                      /* tp_compare */
  36         (reprfunc)ellipsis_repr,                /* tp_repr */
  37         0,                                      /* tp_as_number */
  38         0,                                      /* tp_as_sequence */
  39         0,                                      /* tp_as_mapping */
  40         0,                                      /* tp_hash */
  41         0,                                      /* tp_call */
  42         0,                                      /* tp_str */
  43         PyObject_GenericGetAttr,                /* tp_getattro */
  44         0,                                      /* tp_setattro */
  45         0,                                      /* tp_as_buffer */
  46         Py_TPFLAGS_DEFAULT,                     /* tp_flags */
  47 };
  48
  49 PyObject _Py_EllipsisObject = {
  50         PyObject_HEAD_INIT(&PyEllipsis_Type)
  51 };
  52
  53
  54 /* Slice object implementation
  55
  56    start, stop, and step are python objects with None indicating no
  57    index is present.
  58 */
  59
  60 PyObject *
  61 PySlice_New(PyObject *start, PyObject *stop, PyObject *step)
  62 {
  63         PySliceObject *obj = PyObject_New(PySliceObject, &PySlice_Type);
  64
  65         if (obj == NULL)
  66                 return NULL;
  67
  68         if (step == NULL) step = Py_None;
  69         Py_INCREF(step);
  70         if (start == NULL) start = Py_None;
  71         Py_INCREF(start);
  72         if (stop == NULL) stop = Py_None;
  73         Py_INCREF(stop);
  74
  75         obj->step = step;
  76         obj->start = start;
  77         obj->stop = stop;
  78
  79         return (PyObject *) obj;
  80 }
  81
  82 int
  83 PySlice_GetIndices(PySliceObject *r, int length,
  84                    int *start, int *stop, int *step)
  85 {
  86         if (r->step == Py_None) {
  87                 *step = 1;
  88         } else {
  89                 if (!PyInt_Check(r->step)) return -1;
  90                 *step = PyInt_AsLong(r->step);
  91         }
  92         if (r->start == Py_None) {
  93                 *start = *step < 0 ? length-1 : 0;
  94         } else {
  95                 if (!PyInt_Check(r->start)) return -1;
  96                 *start = PyInt_AsLong(r->start);
  97                 if (*start < 0) *start += length;
  98         }
  99         if (r->stop == Py_None) {
 100                 *stop = *step < 0 ? -1 : length;
 101         } else {
 102                 if (!PyInt_Check(r->stop)) return -1;
 103                 *stop = PyInt_AsLong(r->stop);
 104                 if (*stop < 0) *stop += length;
 105         }
 106         if (*stop > length) return -1;
 107         if (*start >= length) return -1;
 108         if (*step == 0) return -1;
 109         return 0;
 110 }
 111
 112 int
 113 PySlice_GetIndicesEx(PySliceObject *r, int length,
 114                      int *start, int *stop, int *step, int *slicelength)
 115 {
 116         /* this is harder to get right than you might think */
 117         int defstart, defstop;
 118
 119         if (r->step == Py_None) {
 120                 *step = 1;
 121         } else {
 122                 *step = PyInt_AsLong(r->step);
 123                 if (*step == -1 && PyErr_Occurred()) {
 124                         return -1;
 125                 }
 126                 else if (*step == 0) {
 127                         PyErr_SetString(PyExc_ValueError,
 128                                         "slice step cannot be zero");
 129                         return -1;
 130                 }
 131         }
 132
 133         defstart = *step < 0 ? length-1 : 0;
 134         defstop = *step < 0 ? -1 : length;
 135
 136         if (r->start == Py_None) {
 137                 *start = defstart;
 138         } else {
 139                 if (!_PyEval_SliceIndex(r->start, start)) return -1;
 140                 if (*start < 0) *start += length;
 141                 if (*start < 0) *start = (*step < 0) ? -1 : 0;
 142                 if (*start >= length)
 143                         *start = (*step < 0) ? length - 1 : length;
 144         }
 145
 146         if (r->stop == Py_None) {
 147                 *stop = defstop;
 148         } else {
 149                 if (!_PyEval_SliceIndex(r->stop, stop)) return -1;
 150                 if (*stop < 0) *stop += length;
 151                 if (*stop < 0) *stop = -1;
 152                 if (*stop > length) *stop = length;
 153         }
 154
 155         if ((*stop - *start)*(*step) <= 0) {
 156                 *slicelength = 0;
 157         }
 158         else if (*step < 0) {
 159                 *slicelength = (*stop-*start+1)/(*step)+1;
 160         } else {
 161                 *slicelength = (*stop-*start-1)/(*step)+1;
 162         }
 163
 164         return 0;
 165 }
 166
 167 static PyObject *
 168 slice_new(PyTypeObject *type, PyObject *args, PyObject *kw)
 169 {
 170         PyObject *start, *stop, *step;
 171
 172         start = stop = step = NULL;
 173
 174         if (!PyArg_ParseTuple(args, "O|OO:slice", &start, &stop, &step))
 175                 return NULL;
 176
 177         /* This swapping of stop and start is to maintain similarity with
 178            range(). */
 179         if (stop == NULL) {
 180                 stop = start;
 181                 start = NULL;
 182         }
 183         return PySlice_New(start, stop, step);
 184 }
 185
 186 PyDoc_STRVAR(slice_doc,
 187 "slice([start,] stop[, step])\n\
 188 \n\
 189 Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).");
 190
 191 static void
 192 slice_dealloc(PySliceObject *r)
 193 {
 194         Py_DECREF(r->step);
 195         Py_DECREF(r->start);
 196         Py_DECREF(r->stop);
 197         PyObject_Del(r);
 198 }
 199
 200 static PyObject *
 201 slice_repr(PySliceObject *r)
 202 {
 203         PyObject *s, *comma;
 204
 205         s = PyString_FromString("slice(");
 206         comma = PyString_FromString(", ");
 207         PyString_ConcatAndDel(&s, PyObject_Repr(r->start));
 208         PyString_Concat(&s, comma);
 209         PyString_ConcatAndDel(&s, PyObject_Repr(r->stop));
 210         PyString_Concat(&s, comma);
 211         PyString_ConcatAndDel(&s, PyObject_Repr(r->step));
 212         PyString_ConcatAndDel(&s, PyString_FromString(")"));
 213         Py_DECREF(comma);
 214         return s;
 215 }
 216
 217 static PyMemberDef slice_members[] = {
 218         {"start", T_OBJECT, offsetof(PySliceObject, start), READONLY},
 219         {"stop", T_OBJECT, offsetof(PySliceObject, stop), READONLY},
 220         {"step", T_OBJECT, offsetof(PySliceObject, step), READONLY},
 221         {0}
 222 };
 223
 224 static int
 225 slice_compare(PySliceObject *v, PySliceObject *w)
 226 {
 227         int result = 0;
 228
 229         if (v == w)
 230                 return 0;
 231
 232         if (PyObject_Cmp(v->start, w->start, &result) < 0)
 233             return -2;
 234         if (result != 0)
 235                 return result;
 236         if (PyObject_Cmp(v->stop, w->stop, &result) < 0)
 237             return -2;
 238         if (result != 0)
 239                 return result;
 240         if (PyObject_Cmp(v->step, w->step, &result) < 0)
 241             return -2;
 242         return result;
 243 }
 244
 245 PyTypeObject PySlice_Type = {
 246         PyObject_HEAD_INIT(&PyType_Type)
 247         0,                      /* Number of items for varobject */
 248         "slice",                /* Name of this type */
 249         sizeof(PySliceObject),  /* Basic object size */
 250         0,                      /* Item size for varobject */
 251         (destructor)slice_dealloc,              /* tp_dealloc */
 252         0,                                      /* tp_print */
 253         0,                                      /* tp_getattr */
 254         0,                                      /* tp_setattr */
 255         (cmpfunc)slice_compare,                 /* tp_compare */
 256         (reprfunc)slice_repr,                   /* tp_repr */
 257         0,                                      /* tp_as_number */
 258         0,                                      /* tp_as_sequence */
 259         0,                                      /* tp_as_mapping */
 260         0,                                      /* tp_hash */
 261         0,                                      /* tp_call */
 262         0,                                      /* tp_str */
 263         PyObject_GenericGetAttr,                /* tp_getattro */
 264         0,                                      /* tp_setattro */
 265         0,                                      /* tp_as_buffer */
 266         Py_TPFLAGS_DEFAULT,                     /* tp_flags */
 267         slice_doc,                              /* tp_doc */
 268         0,                                      /* tp_traverse */
 269         0,                                      /* tp_clear */
 270         0,                                      /* tp_richcompare */
 271         0,                                      /* tp_weaklistoffset */
 272         0,                                      /* tp_iter */
 273         0,                                      /* tp_iternext */
 274         0,                                      /* tp_methods */
 275         slice_members,                          /* tp_members */
 276         0,                                      /* tp_getset */
 277         0,                                      /* tp_base */
 278         0,                                      /* tp_dict */
 279         0,                                      /* tp_descr_get */
 280         0,                                      /* tp_descr_set */
 281         0,                                      /* tp_dictoffset */
 282         0,                                      /* tp_init */
 283         0,                                      /* tp_alloc */
 284         slice_new,                              /* tp_new */
 285 };