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 PyUnicode_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_reserved */
  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 = PyLong_FromSsize_t(istart);
  87         if (!start)
  88                 return NULL;
  89         end = PyLong_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 (!PyLong_Check(r->step)) return -1;
 110                 *step = PyLong_AsSsize_t(r->step);
 111         }
 112         if (r->start == Py_None) {
 113                 *start = *step < 0 ? length-1 : 0;
 114         } else {
 115                 if (!PyLong_Check(r->start)) return -1;
 116                 *start = PyLong_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 (!PyLong_Check(r->stop)) return -1;
 123                 *stop = PyLong_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         return PyUnicode_FromFormat("slice(%R, %R, %R)", r->start, r->stop, r->step);
 231 }
 232
 233 static PyMemberDef slice_members[] = {
 234         {"start", T_OBJECT, offsetof(PySliceObject, start), READONLY},
 235         {"stop", T_OBJECT, offsetof(PySliceObject, stop), READONLY},
 236         {"step", T_OBJECT, offsetof(PySliceObject, step), READONLY},
 237         {0}
 238 };
 239
 240 static PyObject*
 241 slice_indices(PySliceObject* self, PyObject* len)
 242 {
 243         Py_ssize_t ilen, start, stop, step, slicelength;
 244
 245         ilen = PyNumber_AsSsize_t(len, PyExc_OverflowError);
 246
 247         if (ilen == -1 && PyErr_Occurred()) {
 248                 return NULL;
 249         }
 250
 251         if (PySlice_GetIndicesEx(self, ilen, &start, &stop,
 252                                  &step, &slicelength) < 0) {
 253                 return NULL;
 254         }
 255
 256         return Py_BuildValue("(nnn)", start, stop, step);
 257 }
 258
 259 PyDoc_STRVAR(slice_indices_doc,
 260 "S.indices(len) -> (start, stop, stride)\n\
 261 \n\
 262 Assuming a sequence of length len, calculate the start and stop\n\
 263 indices, and the stride length of the extended slice described by\n\
 264 S. Out of bounds indices are clipped in a manner consistent with the\n\
 265 handling of normal slices.");
 266
 267 static PyObject *
 268 slice_reduce(PySliceObject* self)
 269 {
 270         return Py_BuildValue("O(OOO)", Py_TYPE(self), self->start, self->stop, self->step);
 271 }
 272
 273 PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
 274
 275 static PyMethodDef slice_methods[] = {
 276         {"indices",     (PyCFunction)slice_indices,
 277          METH_O,        slice_indices_doc},
 278         {"__reduce__",  (PyCFunction)slice_reduce,
 279          METH_NOARGS,   reduce_doc},
 280         {NULL, NULL}
 281 };
 282
 283 static PyObject *
 284 slice_richcompare(PyObject *v, PyObject *w, int op)
 285 {
 286         PyObject *t1;
 287         PyObject *t2;
 288         PyObject *res;
 289
 290         if (!PySlice_Check(v) || !PySlice_Check(w)) {
 291                 Py_INCREF(Py_NotImplemented);
 292                 return Py_NotImplemented;
 293         }
 294
 295         if (v == w) {
 296                 /* XXX Do we really need this shortcut?
 297                    There's a unit test for it, but is that fair? */
 298                 switch (op) {
 299                 case Py_EQ:
 300                 case Py_LE:
 301                 case Py_GE:
 302                         res = Py_True;
 303                         break;
 304                 default:
 305                         res = Py_False;
 306                         break;
 307                 }
 308                 Py_INCREF(res);
 309                 return res;
 310         }
 311
 312         t1 = PyTuple_New(3);
 313         t2 = PyTuple_New(3);
 314         if (t1 == NULL || t2 == NULL)
 315                 return NULL;
 316
 317         PyTuple_SET_ITEM(t1, 0, ((PySliceObject *)v)->start);
 318         PyTuple_SET_ITEM(t1, 1, ((PySliceObject *)v)->stop);
 319         PyTuple_SET_ITEM(t1, 2, ((PySliceObject *)v)->step);
 320         PyTuple_SET_ITEM(t2, 0, ((PySliceObject *)w)->start);
 321         PyTuple_SET_ITEM(t2, 1, ((PySliceObject *)w)->stop);
 322         PyTuple_SET_ITEM(t2, 2, ((PySliceObject *)w)->step);
 323
 324         res = PyObject_RichCompare(t1, t2, op);
 325
 326         PyTuple_SET_ITEM(t1, 0, NULL);
 327         PyTuple_SET_ITEM(t1, 1, NULL);
 328         PyTuple_SET_ITEM(t1, 2, NULL);
 329         PyTuple_SET_ITEM(t2, 0, NULL);
 330         PyTuple_SET_ITEM(t2, 1, NULL);
 331         PyTuple_SET_ITEM(t2, 2, NULL);
 332
 333         Py_DECREF(t1);
 334         Py_DECREF(t2);
 335
 336         return res;
 337 }
 338
 339 static long
 340 slice_hash(PySliceObject *v)
 341 {
 342         PyErr_SetString(PyExc_TypeError, "unhashable type");
 343         return -1L;
 344 }
 345
 346 PyTypeObject PySlice_Type = {
 347         PyVarObject_HEAD_INIT(&PyType_Type, 0)
 348         "slice",                /* Name of this type */
 349         sizeof(PySliceObject),  /* Basic object size */
 350         0,                      /* Item size for varobject */
 351         (destructor)slice_dealloc,              /* tp_dealloc */
 352         0,                                      /* tp_print */
 353         0,                                      /* tp_getattr */
 354         0,                                      /* tp_setattr */
 355         0,                                      /* tp_reserved */
 356         (reprfunc)slice_repr,                   /* tp_repr */
 357         0,                                      /* tp_as_number */
 358         0,                                      /* tp_as_sequence */
 359         0,                                      /* tp_as_mapping */
 360         (hashfunc)slice_hash,                   /* tp_hash */
 361         0,                                      /* tp_call */
 362         0,                                      /* tp_str */
 363         PyObject_GenericGetAttr,                /* tp_getattro */
 364         0,                                      /* tp_setattro */
 365         0,                                      /* tp_as_buffer */
 366         Py_TPFLAGS_DEFAULT,                     /* tp_flags */
 367         slice_doc,                              /* tp_doc */
 368         0,                                      /* tp_traverse */
 369         0,                                      /* tp_clear */
 370         slice_richcompare,                      /* tp_richcompare */
 371         0,                                      /* tp_weaklistoffset */
 372         0,                                      /* tp_iter */
 373         0,                                      /* tp_iternext */
 374         slice_methods,                          /* tp_methods */
 375         slice_members,                          /* tp_members */
 376         0,                                      /* tp_getset */
 377         0,                                      /* tp_base */
 378         0,                                      /* tp_dict */
 379         0,                                      /* tp_descr_get */
 380         0,                                      /* tp_descr_set */
 381         0,                                      /* tp_dictoffset */
 382         0,                                      /* tp_init */
 383         0,                                      /* tp_alloc */
 384         slice_new,                              /* tp_new */
 385 };