Objects/rangeobject.c

   1
   2 /* Range object implementation */
   3
   4 #include "Python.h"
   5 #include "structmember.h"
   6 #include <string.h>
   7
   8 typedef struct {
   9         PyObject_HEAD
  10         long    start;
  11         long    step;
  12         long    len;
  13         int     reps;
  14 } rangeobject;
  15
  16
  17 PyObject *
  18 PyRange_New(long start, long len, long step, int reps)
  19 {
  20         rangeobject *obj = PyObject_NEW(rangeobject, &PyRange_Type);
  21
  22         if (obj == NULL)
  23                 return NULL;
  24
  25         obj->start = start;
  26         obj->len   = len;
  27         obj->step  = step;
  28         obj->reps  = reps;
  29
  30         return (PyObject *) obj;
  31 }
  32
  33 static void
  34 range_dealloc(rangeobject *r)
  35 {
  36         PyObject_DEL(r);
  37 }
  38
  39 static PyObject *
  40 range_item(rangeobject *r, int i)
  41 {
  42         if (i < 0 || i >= r->len * r->reps) {
  43                 PyErr_SetString(PyExc_IndexError,
  44                                 "xrange object index out of range");
  45                 return NULL;
  46         }
  47
  48         return PyInt_FromLong(r->start + (i % r->len) * r->step);
  49 }
  50
  51 static int
  52 range_length(rangeobject *r)
  53 {
  54         return r->len * r->reps;
  55 }
  56
  57 static PyObject *
  58 range_repr(rangeobject *r)
  59 {
  60         /* buffers must be big enough to hold 3 longs + an int +
  61          * a bit of "(xrange(...) * ...)" text.
  62          */
  63         char buf1[250];
  64         char buf2[250];
  65
  66         if (r->start == 0 && r->step == 1)
  67                 sprintf(buf1, "xrange(%ld)", r->start + r->len * r->step);
  68
  69         else if (r->step == 1)
  70                 sprintf(buf1, "xrange(%ld, %ld)",
  71                         r->start,
  72                         r->start + r->len * r->step);
  73
  74         else
  75                 sprintf(buf1, "xrange(%ld, %ld, %ld)",
  76                         r->start,
  77                         r->start + r->len * r->step,
  78                         r->step);
  79
  80         if (r->reps != 1)
  81                 sprintf(buf2, "(%s * %d)", buf1, r->reps);
  82
  83         return PyString_FromString(r->reps == 1 ? buf1 : buf2);
  84 }
  85
  86 static PyObject *
  87 range_concat(rangeobject *r, PyObject *obj)
  88 {
  89         PyErr_SetString(PyExc_TypeError, "cannot concatenate xrange objects");
  90         return NULL;
  91 }
  92
  93 static PyObject *
  94 range_repeat(rangeobject *r, int n)
  95 {
  96         if (n < 0)
  97                 return (PyObject *) PyRange_New(0, 0, 1, 1);
  98
  99         else if (n == 1) {
 100                 Py_INCREF(r);
 101                 return (PyObject *) r;
 102         }
 103
 104         else
 105                 return (PyObject *) PyRange_New(
 106                                                 r->start,
 107                                                 r->len,
 108                                                 r->step,
 109                                                 r->reps * n);
 110 }
 111
 112 static int
 113 range_compare(rangeobject *r1, rangeobject *r2)
 114 {
 115         if (r1->start != r2->start)
 116                 return r1->start - r2->start;
 117
 118         else if (r1->step != r2->step)
 119                 return r1->step - r2->step;
 120
 121         else if (r1->len != r2->len)
 122                 return r1->len - r2->len;
 123
 124         else
 125                 return r1->reps - r2->reps;
 126 }
 127
 128 static PyObject *
 129 range_slice(rangeobject *r, int low, int high)
 130 {
 131         if (r->reps != 1) {
 132                 PyErr_SetString(PyExc_TypeError,
 133                                 "cannot slice a replicated xrange");
 134                 return NULL;
 135         }
 136         if (low < 0)
 137                 low = 0;
 138         else if (low > r->len)
 139                 low = r->len;
 140         if (high < 0)
 141                 high = 0;
 142         if (high < low)
 143                 high = low;
 144         else if (high > r->len)
 145                 high = r->len;
 146
 147         if (low == 0 && high == r->len) {
 148                 Py_INCREF(r);
 149                 return (PyObject *) r;
 150         }
 151
 152         return (PyObject *) PyRange_New(
 153                                 low * r->step + r->start,
 154                                 high - low,
 155                                 r->step,
 156                                 1);
 157 }
 158
 159 static PyObject *
 160 range_tolist(rangeobject *self, PyObject *args)
 161 {
 162         PyObject *thelist;
 163         int j;
 164         int len = self->len * self->reps;
 165
 166         if (! PyArg_ParseTuple(args, ":tolist"))
 167                 return NULL;
 168
 169         if ((thelist = PyList_New(len)) == NULL)
 170                 return NULL;
 171
 172         for (j = 0; j < len; ++j)
 173                 if ((PyList_SetItem(thelist, j, (PyObject *) PyInt_FromLong(
 174                         self->start + (j % self->len) * self->step))) < 0)
 175                         return NULL;
 176
 177         return thelist;
 178 }
 179
 180 static PyObject *
 181 range_getattr(rangeobject *r, char *name)
 182 {
 183         PyObject *result;
 184
 185         static PyMethodDef range_methods[] = {
 186                 {"tolist",      (PyCFunction)range_tolist, METH_VARARGS,
 187                  "tolist() -> list\n"
 188                  "Return a list object with the same values."},
 189                 {NULL,          NULL}
 190         };
 191         static struct memberlist range_members[] = {
 192                 {"step",  T_LONG, offsetof(rangeobject, step), RO},
 193                 {"start", T_LONG, offsetof(rangeobject, start), RO},
 194                 {"stop",  T_LONG, 0, RO},
 195                 {NULL, 0, 0, 0}
 196         };
 197
 198         result = Py_FindMethod(range_methods, (PyObject *) r, name);
 199         if (result == NULL) {
 200                 PyErr_Clear();
 201                 if (strcmp("stop", name) == 0)
 202                         result = PyInt_FromLong(r->start + (r->len * r->step));
 203                 else
 204                         result = PyMember_Get((char *)r, range_members, name);
 205         }
 206         return result;
 207 }
 208
 209 static int
 210 range_contains(rangeobject *r, PyObject *obj)
 211 {
 212         long num = PyInt_AsLong(obj);
 213
 214         if (num < 0 && PyErr_Occurred())
 215                 return -1;
 216
 217         if (r->step > 0) {
 218                 if ((num < r->start) || ((num - r->start) % r->step))
 219                         return 0;
 220                 if (num >= (r->start + (r->len * r->step)))
 221                         return 0;
 222         }
 223         else {
 224                 if ((num > r->start) || ((num - r->start) % r->step))
 225                         return 0;
 226                 if (num <= (r->start + (r->len * r->step)))
 227                         return 0;
 228         }
 229         return 1;
 230 }
 231
 232 static PySequenceMethods range_as_sequence = {
 233         (inquiry)range_length,  /*sq_length*/
 234         (binaryfunc)range_concat, /*sq_concat*/
 235         (intargfunc)range_repeat, /*sq_repeat*/
 236         (intargfunc)range_item, /*sq_item*/
 237         (intintargfunc)range_slice, /*sq_slice*/
 238         0,                      /*sq_ass_item*/
 239         0,                      /*sq_ass_slice*/
 240         (objobjproc)range_contains, /*sq_contains*/
 241 };
 242
 243 PyTypeObject PyRange_Type = {
 244         PyObject_HEAD_INIT(&PyType_Type)
 245         0,                      /* Number of items for varobject */
 246         "xrange",               /* Name of this type */
 247         sizeof(rangeobject),    /* Basic object size */
 248         0,                      /* Item size for varobject */
 249         (destructor)range_dealloc, /*tp_dealloc*/
 250         0,                      /*tp_print*/
 251         (getattrfunc)range_getattr, /*tp_getattr*/
 252         0,                      /*tp_setattr*/
 253         (cmpfunc)range_compare, /*tp_compare*/
 254         (reprfunc)range_repr,   /*tp_repr*/
 255         0,                      /*tp_as_number*/
 256         &range_as_sequence,     /*tp_as_sequence*/
 257         0,                      /*tp_as_mapping*/
 258         0,                      /*tp_hash*/
 259         0,                      /*tp_call*/
 260         0,                      /*tp_str*/
 261         0,                      /*tp_getattro*/
 262         0,                      /*tp_setattro*/
 263         0,                      /*tp_as_buffer*/
 264         Py_TPFLAGS_DEFAULT,     /*tp_flags*/
 265 };