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 PyTypeObject PyEllipsis_Type = {
  26         PyVarObject_HEAD_INIT(&PyType_Type, 0)
  27         "ellipsis",                     /* tp_name */
  28         0,                              /* tp_basicsize */
  29         0,                              /* tp_itemsize */
  30         0, /*never called*/             /* tp_dealloc */
  31         0,                              /* tp_print */
  32         0,                              /* tp_getattr */
  33         0,                              /* tp_setattr */
  34         0,                              /* tp_compare */
  35         ellipsis_repr,                  /* tp_repr */
  36         0,                              /* tp_as_number */
  37         0,                              /* tp_as_sequence */
  38         0,                              /* tp_as_mapping */
  39         0,                              /* tp_hash */
  40         0,                              /* tp_call */
  41         0,                              /* tp_str */
  42         PyObject_GenericGetAttr,        /* tp_getattro */
  43         0,                              /* tp_setattro */
  44         0,                              /* tp_as_buffer */
  45         Py_TPFLAGS_DEFAULT,             /* tp_flags */
  46 };
  47
  48 PyObject _Py_EllipsisObject = {
  49         _PyObject_EXTRA_INIT
  50         1, &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 PyObject *
  83 _PySlice_FromIndices(Py_ssize_t istart, Py_ssize_t istop)
  84 {
  85         PyObject *start, *end, *slice;
  86         start = PyInt_FromSsize_t(istart);
  87         if (!start)
  88                 return NULL;
  89         end = PyInt_FromSsize_t(istop);
  90         if (!end) {
  91                 Py_DECREF(start);
  92                 return NULL;
  93         }
  94
  95         slice = PySlice_New(start, end, NULL);
  96         Py_DECREF(start);
  97         Py_DECREF(end);
  98         return slice;
  99 }
 100
 101 int
 102 PySlice_GetIndices(PySliceObject *r, Py_ssize_t length,
 103                    Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step)
 104 {
 105         /* XXX support long ints */
 106         if (r->step == Py_None) {
 107                 *step = 1;
 108         } else {
 109                 if (!PyInt_Check(r->step) && !PyLong_Check(r->step)) return -1;
 110                 *step = PyInt_AsSsize_t(r->step);
 111         }
 112         if (r->start == Py_None) {
 113                 *start = *step < 0 ? length-1 : 0;
 114         } else {
 115                 if (!PyInt_Check(r->start) && !PyLong_Check(r->step)) return -1;
 116                 *start = PyInt_AsSsize_t(r->start);
 117                 if (*start < 0) *start += length;
 118         }
 119         if (r->stop == Py_None) {
 120                 *stop = *step < 0 ? -1 : length;
 121         } else {
 122                 if (!PyInt_Check(r->stop) && !PyLong_Check(r->step)) return -1;
 123                 *stop = PyInt_AsSsize_t(r->stop);
 124                 if (*stop < 0) *stop += length;
 125         }
 126         if (*stop > length) return -1;
 127         if (*start >= length) return -1;
 128         if (*step == 0) return -1;
 129         return 0;
 130 }
 131
 132 int
 133 PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length,
 134                      Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step, Py_ssize_t *slicelength)
 135 {
 136         /* this is harder to get right than you might think */
 137
 138         Py_ssize_t defstart, defstop;
 139
 140         if (r->step == Py_None) {
 141                 *step = 1;
 142         }
 143         else {
 144                 if (!_PyEval_SliceIndex(r->step, step)) return -1;
 145                 if (*step == 0) {
 146                         PyErr_SetString(PyExc_ValueError,
 147                                         "slice step cannot be zero");
 148                         return -1;
 149                 }
 150         }
 151
 152         defstart = *step < 0 ? length-1 : 0;
 153         defstop = *step < 0 ? -1 : length;
 154
 155         if (r->start == Py_None) {
 156                 *start = defstart;
 157         }
 158         else {
 159                 if (!_PyEval_SliceIndex(r->start, start)) return -1;
 160                 if (*start < 0) *start += length;
 161                 if (*start < 0) *start = (*step < 0) ? -1 : 0;
 162                 if (*start >= length)
 163                         *start = (*step < 0) ? length - 1 : length;
 164         }
 165
 166         if (r->stop == Py_None) {
 167                 *stop = defstop;
 168         }
 169         else {
 170                 if (!_PyEval_SliceIndex(r->stop, stop)) return -1;
 171                 if (*stop < 0) *stop += length;
 172                 if (*stop < 0) *stop = (*step < 0) ? -1 : 0;
 173                 if (*stop >= length)
 174                         *stop = (*step < 0) ? length - 1 : length;
 175         }
 176
 177         if ((*step < 0 && *stop >= *start)
 178             || (*step > 0 && *start >= *stop)) {
 179                 *slicelength = 0;
 180         }
 181         else if (*step < 0) {
 182                 *slicelength = (*stop-*start+1)/(*step)+1;
 183         }
 184         else {
 185                 *slicelength = (*stop-*start-1)/(*step)+1;
 186         }
 187
 188         return 0;
 189 }
 190
 191 static PyObject *
 192 slice_new(PyTypeObject *type, PyObject *args, PyObject *kw)
 193 {
 194         PyObject *start, *stop, *step;
 195
 196         start = stop = step = NULL;
 197
 198         if (!_PyArg_NoKeywords("slice()", kw))
 199                 return NULL;
 200
 201         if (!PyArg_UnpackTuple(args, "slice", 1, 3, &start, &stop, &step))
 202                 return NULL;
 203
 204         /* This swapping of stop and start is to maintain similarity with
 205            range(). */
 206         if (stop == NULL) {
 207                 stop = start;
 208                 start = NULL;
 209         }
 210         return PySlice_New(start, stop, step);
 211 }
 212
 213 PyDoc_STRVAR(slice_doc,
 214 "slice([start,] stop[, step])\n\
 215 \n\
 216 Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).");
 217
 218 static void
 219 slice_dealloc(PySliceObject *r)
 220 {
 221         Py_DECREF(r->step);
 222         Py_DECREF(r->start);
 223         Py_DECREF(r->stop);
 224         PyObject_Del(r);
 225 }
 226
 227 static PyObject *
 228 slice_repr(PySliceObject *r)
 229 {
 230         PyObject *s, *comma;
 231
 232         s = PyString_FromString("slice(");
 233         comma = PyString_FromString(", ");
 234         PyString_ConcatAndDel(&s, PyObject_Repr(r->start));
 235         PyString_Concat(&s, comma);
 236         PyString_ConcatAndDel(&s, PyObject_Repr(r->stop));
 237         PyString_Concat(&s, comma);
 238         PyString_ConcatAndDel(&s, PyObject_Repr(r->step));
 239         PyString_ConcatAndDel(&s, PyString_FromString(")"));
 240         Py_DECREF(comma);
 241         return s;
 242 }
 243
 244 static PyMemberDef slice_members[] = {
 245         {"start", T_OBJECT, offsetof(PySliceObject, start), READONLY},
 246         {"stop", T_OBJECT, offsetof(PySliceObject, stop), READONLY},
 247         {"step", T_OBJECT, offsetof(PySliceObject, step), READONLY},
 248         {0}
 249 };
 250
 251 static PyObject*
 252 slice_indices(PySliceObject* self, PyObject* len)
 253 {
 254         Py_ssize_t ilen, start, stop, step, slicelength;
 255
 256         ilen = PyNumber_AsSsize_t(len, PyExc_OverflowError);
 257
 258         if (ilen == -1 && PyErr_Occurred()) {
 259                 return NULL;
 260         }
 261
 262         if (PySlice_GetIndicesEx(self, ilen, &start, &stop,
 263                                  &step, &slicelength) < 0) {
 264                 return NULL;
 265         }
 266
 267         return Py_BuildValue("(nnn)", start, stop, step);
 268 }
 269
 270 PyDoc_STRVAR(slice_indices_doc,
 271 "S.indices(len) -> (start, stop, stride)\n\
 272 \n\
 273 Assuming a sequence of length len, calculate the start and stop\n\
 274 indices, and the stride length of the extended slice described by\n\
 275 S. Out of bounds indices are clipped in a manner consistent with the\n\
 276 handling of normal slices.");
 277
 278 static PyObject *
 279 slice_reduce(PySliceObject* self)
 280 {
 281         return Py_BuildValue("O(OOO)", Py_TYPE(self), self->start, self->stop, self->step);
 282 }
 283
 284 PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
 285
 286 static PyMethodDef slice_methods[] = {
 287         {"indices",     (PyCFunction)slice_indices,
 288          METH_O,        slice_indices_doc},
 289         {"__reduce__",  (PyCFunction)slice_reduce,
 290          METH_NOARGS,   reduce_doc},
 291         {NULL, NULL}
 292 };
 293
 294 static int
 295 slice_compare(PySliceObject *v, PySliceObject *w)
 296 {
 297         int result = 0;
 298
 299         if (v == w)
 300                 return 0;
 301
 302         if (PyObject_Cmp(v->start, w->start, &result) < 0)
 303             return -2;
 304         if (result != 0)
 305                 return result;
 306         if (PyObject_Cmp(v->stop, w->stop, &result) < 0)
 307             return -2;
 308         if (result != 0)
 309                 return result;
 310         if (PyObject_Cmp(v->step, w->step, &result) < 0)
 311             return -2;
 312         return result;
 313 }
 314
 315 static long
 316 slice_hash(PySliceObject *v)
 317 {
 318         PyErr_SetString(PyExc_TypeError, "unhashable type");
 319         return -1L;
 320 }
 321
 322 PyTypeObject PySlice_Type = {
 323         PyVarObject_HEAD_INIT(&PyType_Type, 0)
 324         "slice",                /* Name of this type */
 325         sizeof(PySliceObject),  /* Basic object size */
 326         0,                      /* Item size for varobject */
 327         (destructor)slice_dealloc,              /* tp_dealloc */
 328         0,                                      /* tp_print */
 329         0,                                      /* tp_getattr */
 330         0,                                      /* tp_setattr */
 331         (cmpfunc)slice_compare,                 /* tp_compare */
 332         (reprfunc)slice_repr,                   /* tp_repr */
 333         0,                                      /* tp_as_number */
 334         0,                                      /* tp_as_sequence */
 335         0,                                      /* tp_as_mapping */
 336         (hashfunc)slice_hash,                   /* tp_hash */
 337         0,                                      /* tp_call */
 338         0,                                      /* tp_str */
 339         PyObject_GenericGetAttr,                /* tp_getattro */
 340         0,                                      /* tp_setattro */
 341         0,                                      /* tp_as_buffer */
 342         Py_TPFLAGS_DEFAULT,                     /* tp_flags */
 343         slice_doc,                              /* tp_doc */
 344         0,                                      /* tp_traverse */
 345         0,                                      /* tp_clear */
 346         0,                                      /* tp_richcompare */
 347         0,                                      /* tp_weaklistoffset */
 348         0,                                      /* tp_iter */
 349         0,                                      /* tp_iternext */
 350         slice_methods,                          /* tp_methods */
 351         slice_members,                          /* tp_members */
 352         0,                                      /* tp_getset */
 353         0,                                      /* tp_base */
 354         0,                                      /* tp_dict */
 355         0,                                      /* tp_descr_get */
 356         0,                                      /* tp_descr_set */
 357         0,                                      /* tp_dictoffset */
 358         0,                                      /* tp_init */
 359         0,                                      /* tp_alloc */
 360         slice_new,                              /* tp_new */
 361 };