source: python/vendor/current/Objects/sliceobject.c

Last change on this file was 388, checked in by dmik, 11 years ago

python: Update vendor to 2.7.6.
  • Property svn:eol-style set to native
File size: 10.8 KB
Line 
1/*
2Written by Jim Hugunin and Chris Chase.
3
4This includes both the singular ellipsis object and slice objects.
5
6Guido, feel free to do whatever you want in the way of copyrights
7for this file.
8*/
9
10/*
11Py_Ellipsis encodes the '...' rubber index token. It is similar to
12the Py_NoneStruct in that there is no way to create other objects of
13this type and there is exactly one in existence.
14*/
15
16#include "Python.h"
17#include "structmember.h"
18
19static PyObject *
20ellipsis_repr(PyObject *op)
21{
22 return PyString_FromString("Ellipsis");
23}
24
25PyTypeObject 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
48PyObject _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
60PyObject *
61PySlice_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
82PyObject *
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
101int
102PySlice_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
132int
133PySlice_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
191static PyObject *
192slice_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
213PyDoc_STRVAR(slice_doc,
214"slice(stop)\n\
215slice(start, stop[, step])\n\
216\n\
217Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).");
218
219static void
220slice_dealloc(PySliceObject *r)
221{
222 Py_DECREF(r->step);
223 Py_DECREF(r->start);
224 Py_DECREF(r->stop);
225 PyObject_Del(r);
226}
227
228static PyObject *
229slice_repr(PySliceObject *r)
230{
231 PyObject *s, *comma;
232
233 s = PyString_FromString("slice(");
234 comma = PyString_FromString(", ");
235 PyString_ConcatAndDel(&s, PyObject_Repr(r->start));
236 PyString_Concat(&s, comma);
237 PyString_ConcatAndDel(&s, PyObject_Repr(r->stop));
238 PyString_Concat(&s, comma);
239 PyString_ConcatAndDel(&s, PyObject_Repr(r->step));
240 PyString_ConcatAndDel(&s, PyString_FromString(")"));
241 Py_DECREF(comma);
242 return s;
243}
244
245static PyMemberDef slice_members[] = {
246 {"start", T_OBJECT, offsetof(PySliceObject, start), READONLY},
247 {"stop", T_OBJECT, offsetof(PySliceObject, stop), READONLY},
248 {"step", T_OBJECT, offsetof(PySliceObject, step), READONLY},
249 {0}
250};
251
252static PyObject*
253slice_indices(PySliceObject* self, PyObject* len)
254{
255 Py_ssize_t ilen, start, stop, step, slicelength;
256
257 ilen = PyNumber_AsSsize_t(len, PyExc_OverflowError);
258
259 if (ilen == -1 && PyErr_Occurred()) {
260 return NULL;
261 }
262
263 if (PySlice_GetIndicesEx(self, ilen, &start, &stop,
264 &step, &slicelength) < 0) {
265 return NULL;
266 }
267
268 return Py_BuildValue("(nnn)", start, stop, step);
269}
270
271PyDoc_STRVAR(slice_indices_doc,
272"S.indices(len) -> (start, stop, stride)\n\
273\n\
274Assuming a sequence of length len, calculate the start and stop\n\
275indices, and the stride length of the extended slice described by\n\
276S. Out of bounds indices are clipped in a manner consistent with the\n\
277handling of normal slices.");
278
279static PyObject *
280slice_reduce(PySliceObject* self)
281{
282 return Py_BuildValue("O(OOO)", Py_TYPE(self), self->start, self->stop, self->step);
283}
284
285PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
286
287static PyMethodDef slice_methods[] = {
288 {"indices", (PyCFunction)slice_indices,
289 METH_O, slice_indices_doc},
290 {"__reduce__", (PyCFunction)slice_reduce,
291 METH_NOARGS, reduce_doc},
292 {NULL, NULL}
293};
294
295static int
296slice_compare(PySliceObject *v, PySliceObject *w)
297{
298 int result = 0;
299
300 if (v == w)
301 return 0;
302
303 if (PyObject_Cmp(v->start, w->start, &result) < 0)
304 return -2;
305 if (result != 0)
306 return result;
307 if (PyObject_Cmp(v->stop, w->stop, &result) < 0)
308 return -2;
309 if (result != 0)
310 return result;
311 if (PyObject_Cmp(v->step, w->step, &result) < 0)
312 return -2;
313 return result;
314}
315
316static long
317slice_hash(PySliceObject *v)
318{
319 PyErr_SetString(PyExc_TypeError, "unhashable type");
320 return -1L;
321}
322
323PyTypeObject PySlice_Type = {
324 PyVarObject_HEAD_INIT(&PyType_Type, 0)
325 "slice", /* Name of this type */
326 sizeof(PySliceObject), /* Basic object size */
327 0, /* Item size for varobject */
328 (destructor)slice_dealloc, /* tp_dealloc */
329 0, /* tp_print */
330 0, /* tp_getattr */
331 0, /* tp_setattr */
332 (cmpfunc)slice_compare, /* tp_compare */
333 (reprfunc)slice_repr, /* tp_repr */
334 0, /* tp_as_number */
335 0, /* tp_as_sequence */
336 0, /* tp_as_mapping */
337 (hashfunc)slice_hash, /* tp_hash */
338 0, /* tp_call */
339 0, /* tp_str */
340 PyObject_GenericGetAttr, /* tp_getattro */
341 0, /* tp_setattro */
342 0, /* tp_as_buffer */
343 Py_TPFLAGS_DEFAULT, /* tp_flags */
344 slice_doc, /* tp_doc */
345 0, /* tp_traverse */
346 0, /* tp_clear */
347 0, /* tp_richcompare */
348 0, /* tp_weaklistoffset */
349 0, /* tp_iter */
350 0, /* tp_iternext */
351 slice_methods, /* tp_methods */
352 slice_members, /* tp_members */
353 0, /* tp_getset */
354 0, /* tp_base */
355 0, /* tp_dict */
356 0, /* tp_descr_get */
357 0, /* tp_descr_set */
358 0, /* tp_dictoffset */
359 0, /* tp_init */
360 0, /* tp_alloc */
361 slice_new, /* tp_new */
362};
Note: See TracBrowser for help on using the repository browser.