ObjectHandling.c 32.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/////////////// RaiseNoneIterError.proto ///////////////

static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);

/////////////// RaiseNoneIterError ///////////////

static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
}

/////////////// RaiseTooManyValuesToUnpack.proto ///////////////

static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);

/////////////// RaiseTooManyValuesToUnpack ///////////////

static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
    PyErr_Format(PyExc_ValueError,
cgohlke's avatar
cgohlke committed
19
                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
20 21 22 23 24 25 26 27 28 29
}

/////////////// RaiseNeedMoreValuesToUnpack.proto ///////////////

static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);

/////////////// RaiseNeedMoreValuesToUnpack ///////////////

static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
    PyErr_Format(PyExc_ValueError,
cgohlke's avatar
cgohlke committed
30
                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%s to unpack",
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
                 index, (index == 1) ? "" : "s");
}

/////////////// UnpackTupleError.proto ///////////////

static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /*proto*/

/////////////// UnpackTupleError ///////////////
//@requires: RaiseNoneIterError
//@requires: RaiseNeedMoreValuesToUnpack
//@requires: RaiseTooManyValuesToUnpack

static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
    if (t == Py_None) {
      __Pyx_RaiseNoneNotIterableError();
    } else if (PyTuple_GET_SIZE(t) < index) {
      __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t));
    } else {
      __Pyx_RaiseTooManyValuesError(index);
    }
}

/////////////// UnpackItemEndCheck.proto ///////////////

static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /*proto*/

/////////////// UnpackItemEndCheck ///////////////
//@requires: RaiseTooManyValuesToUnpack
59
//@requires: IterFinish
60 61 62 63 64 65

static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
    if (unlikely(retval)) {
        Py_DECREF(retval);
        __Pyx_RaiseTooManyValuesError(expected);
        return -1;
66 67
    } else {
        return __Pyx_IterFinish();
68 69 70 71 72 73 74 75 76 77 78 79
    }
    return 0;
}

/////////////// UnpackTuple2.proto ///////////////

static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** value1, PyObject** value2,
                                             int is_tuple, int has_known_size, int decref_tuple);

/////////////// UnpackTuple2 ///////////////
//@requires: UnpackItemEndCheck
//@requires: UnpackTupleError
80
//@requires: RaiseNeedMoreValuesToUnpack
81 82 83

static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2,
                                             int is_tuple, int has_known_size, int decref_tuple) {
84
    Py_ssize_t index;
85 86
    PyObject *value1 = NULL, *value2 = NULL, *iter = NULL;
    if (!is_tuple && unlikely(!PyTuple_Check(tuple))) {
87
        iternextfunc iternext;
88 89
        iter = PyObject_GetIter(tuple);
        if (unlikely(!iter)) goto bad;
90
        if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; }
91 92 93
        iternext = Py_TYPE(iter)->tp_iternext;
        value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; }
        value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; }
94
        if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad;
95 96 97 98 99 100
        Py_DECREF(iter);
    } else {
        if (!has_known_size && unlikely(PyTuple_GET_SIZE(tuple) != 2)) {
            __Pyx_UnpackTupleError(tuple, 2);
            goto bad;
        }
101
#if CYTHON_COMPILING_IN_PYPY
102
        value1 = PySequence_ITEM(tuple, 0);
103
        if (unlikely(!value1)) goto bad;
104
        value2 = PySequence_ITEM(tuple, 1);
105 106
        if (unlikely(!value2)) goto bad;
#else
107 108
        value1 = PyTuple_GET_ITEM(tuple, 0);
        value2 = PyTuple_GET_ITEM(tuple, 1);
109 110
        Py_INCREF(value1);
        Py_INCREF(value2);
111
#endif
112
        if (decref_tuple) { Py_DECREF(tuple); }
113 114 115 116
    }
    *pvalue1 = value1;
    *pvalue2 = value2;
    return 0;
117 118 119
unpacking_failed:
    if (!has_known_size && __Pyx_IterFinish() == 0)
        __Pyx_RaiseNeedMoreValuesError(index);
120 121 122 123
bad:
    Py_XDECREF(iter);
    Py_XDECREF(value1);
    Py_XDECREF(value2);
124
    if (decref_tuple) { Py_XDECREF(tuple); }
125 126
    return -1;
}
127

128 129
/////////////// IterNext.proto ///////////////

130
#define __Pyx_PyIter_Next(obj) __Pyx_PyIter_Next2(obj, NULL)
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *); /*proto*/

/////////////// IterNext ///////////////

// originally copied from Py3's builtin_next()
static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) {
    PyObject* next;
    iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
#if CYTHON_COMPILING_IN_CPYTHON
    if (unlikely(!iternext)) {
#else
    if (unlikely(!iternext) || unlikely(!PyIter_Check(iterator))) {
#endif
        PyErr_Format(PyExc_TypeError,
            "%.200s object is not an iterator", Py_TYPE(iterator)->tp_name);
        return NULL;
    }
    next = iternext(iterator);
    if (likely(next))
        return next;
#if CYTHON_COMPILING_IN_CPYTHON
152 153
#if PY_VERSION_HEX >= 0x03010000 || (PY_MAJOR_VERSION < 3 && PY_VERSION_HEX >= 0x02070000)
    if (unlikely(iternext == &_PyObject_NextNotImplemented))
154 155 156
        return NULL;
#endif
#endif
157
    if (defval) {
158 159 160 161 162 163 164 165 166 167
        PyObject* exc_type = PyErr_Occurred();
        if (exc_type) {
            if (unlikely(exc_type != PyExc_StopIteration) &&
                    !PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))
                return NULL;
            PyErr_Clear();
        }
        Py_INCREF(defval);
        return defval;
    }
168 169 170
    if (!PyErr_Occurred())
        PyErr_SetNone(PyExc_StopIteration);
    return NULL;
171 172
}

173 174
/////////////// IterFinish.proto ///////////////

175
static CYTHON_INLINE int __Pyx_IterFinish(void); /*proto*/
176 177 178 179 180 181 182

/////////////// IterFinish ///////////////

// When PyIter_Next(iter) has returned NULL in order to signal termination,
// this function does the right cleanup and returns 0 on success.  If it
// detects an error that occurred in the iterator, it returns -1.

183
static CYTHON_INLINE int __Pyx_IterFinish(void) {
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
#if CYTHON_COMPILING_IN_CPYTHON
    PyThreadState *tstate = PyThreadState_GET();
    PyObject* exc_type = tstate->curexc_type;
    if (unlikely(exc_type)) {
        if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) {
            PyObject *exc_value, *exc_tb;
            exc_value = tstate->curexc_value;
            exc_tb = tstate->curexc_traceback;
            tstate->curexc_type = 0;
            tstate->curexc_value = 0;
            tstate->curexc_traceback = 0;
            Py_DECREF(exc_type);
            Py_XDECREF(exc_value);
            Py_XDECREF(exc_tb);
            return 0;
        } else {
            return -1;
        }
    }
    return 0;
#else
205 206 207 208 209 210 211 212 213
    if (unlikely(PyErr_Occurred())) {
        if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
            PyErr_Clear();
            return 0;
        } else {
            return -1;
        }
    }
    return 0;
214
#endif
215
}
216

217 218 219 220 221 222 223
/////////////// DictGetItem.proto ///////////////

#if PY_MAJOR_VERSION >= 3
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
    PyObject *value;
    value = PyDict_GetItemWithError(d, key);
    if (unlikely(!value)) {
224 225 226 227 228 229
        if (!PyErr_Occurred()) {
            PyObject* args = PyTuple_Pack(1, key);
            if (likely(args))
                PyErr_SetObject(PyExc_KeyError, args);
            Py_XDECREF(args);
        }
230 231 232 233 234 235 236 237 238
        return NULL;
    }
    Py_INCREF(value);
    return value;
}
#else
    #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
#endif

239 240
/////////////// GetItemInt.proto ///////////////

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
#define __Pyx_GetItemInt(o, i, size, to_py_func, is_list, wraparound, boundscheck) \
    (((size) <= sizeof(Py_ssize_t)) ? \
    __Pyx_GetItemInt_Fast(o, i, is_list, wraparound, boundscheck) : \
    __Pyx_GetItemInt_Generic(o, to_py_func(i)))

{{for type in ['List', 'Tuple']}}
#define __Pyx_GetItemInt_{{type}}(o, i, size, to_py_func, is_list, wraparound, boundscheck) \
    (((size) <= sizeof(Py_ssize_t)) ? \
    __Pyx_GetItemInt_{{type}}_Fast(o, i, wraparound, boundscheck) : \
    __Pyx_GetItemInt_Generic(o, to_py_func(i)))

static CYTHON_INLINE PyObject *__Pyx_GetItemInt_{{type}}_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck);
{{endfor}}

static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
                                                     int is_list, int wraparound, int boundscheck);

/////////////// GetItemInt ///////////////

262 263 264 265 266 267 268 269 270
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
    PyObject *r;
    if (!j) return NULL;
    r = PyObject_GetItem(o, j);
    Py_DECREF(j);
    return r;
}

{{for type in ['List', 'Tuple']}}
271 272
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_{{type}}_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck) {
273
#if CYTHON_COMPILING_IN_CPYTHON
274 275
    if (wraparound & unlikely(i < 0)) i += Py{{type}}_GET_SIZE(o);
    if ((!boundscheck) || likely((0 <= i) & (i < Py{{type}}_GET_SIZE(o)))) {
276 277 278 279 280 281 282 283 284 285 286
        PyObject *r = Py{{type}}_GET_ITEM(o, i);
        Py_INCREF(r);
        return r;
    }
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
#else
    return PySequence_GetItem(o, i);
#endif
}
{{endfor}}

287 288
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
                                                     int is_list, int wraparound, int boundscheck) {
289
#if CYTHON_COMPILING_IN_CPYTHON
290 291 292
    if (is_list || PyList_CheckExact(o)) {
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
        if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) {
293 294 295 296 297 298
            PyObject *r = PyList_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
    }
    else if (PyTuple_CheckExact(o)) {
299 300
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
        if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) {
301 302 303 304
            PyObject *r = PyTuple_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
305 306
    } else {
        // inlined PySequence_GetItem() + special cased length overflow
307 308
        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
        if (likely(m && m->sq_item)) {
309
            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
310
                Py_ssize_t l = m->sq_length(o);
311 312 313 314 315 316 317 318 319
                if (likely(l >= 0)) {
                    i += l;
                } else {
                    // if length > max(Py_ssize_t), maybe the object can wrap around itself?
                    if (PyErr_ExceptionMatches(PyExc_OverflowError))
                        PyErr_Clear();
                    else
                        return NULL;
                }
320 321 322 323 324
            }
            return m->sq_item(o, i);
        }
    }
#else
325
    if (is_list || PySequence_Check(o)) {
326 327 328 329 330 331
        return PySequence_GetItem(o, i);
    }
#endif
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
}

332 333
/////////////// SetItemInt.proto ///////////////

334 335 336 337
#define __Pyx_SetItemInt(o, i, v, size, to_py_func, is_list, wraparound, boundscheck) \
    (((size) <= sizeof(Py_ssize_t)) ? \
    __Pyx_SetItemInt_Fast(o, i, v, is_list, wraparound, boundscheck) : \
    __Pyx_SetItemInt_Generic(o, to_py_func(i), v))
338

339 340 341 342 343 344
static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v);
static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
                                               int is_list, int wraparound, int boundscheck);

/////////////// SetItemInt ///////////////

345 346 347 348 349 350 351 352
static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
    int r;
    if (!j) return -1;
    r = PyObject_SetItem(o, j, v);
    Py_DECREF(j);
    return r;
}

353 354
static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
                                               int is_list, int wraparound, int boundscheck) {
355
#if CYTHON_COMPILING_IN_CPYTHON
356 357 358
    if (is_list || PyList_CheckExact(o)) {
        Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o));
        if ((!boundscheck) || likely((n >= 0) & (n < PyList_GET_SIZE(o)))) {
359 360 361 362 363 364
            PyObject* old = PyList_GET_ITEM(o, n);
            Py_INCREF(v);
            PyList_SET_ITEM(o, n, v);
            Py_DECREF(old);
            return 1;
        }
365 366
    } else {
        // inlined PySequence_SetItem() + special cased length overflow
367 368
        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
        if (likely(m && m->sq_ass_item)) {
369
            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
370
                Py_ssize_t l = m->sq_length(o);
371 372 373 374 375 376 377 378 379
                if (likely(l >= 0)) {
                    i += l;
                } else {
                    // if length > max(Py_ssize_t), maybe the object can wrap around itself?
                    if (PyErr_ExceptionMatches(PyExc_OverflowError))
                        PyErr_Clear();
                    else
                        return -1;
                }
380 381 382 383 384 385
            }
            return m->sq_ass_item(o, i, v);
        }
    }
#else
#if CYTHON_COMPILING_IN_PYPY
386
    if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) {
387
#else
388
    if (is_list || PySequence_Check(o)) {
389 390 391 392 393 394 395
#endif
        return PySequence_SetItem(o, i, v);
    }
#endif
    return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
}

396

397 398
/////////////// DelItemInt.proto ///////////////

399 400
#define __Pyx_DelItemInt(o, i, size, to_py_func, is_list, wraparound, boundscheck) \
    (((size) <= sizeof(Py_ssize_t)) ? \
401
    __Pyx_DelItemInt_Fast(o, i, is_list, wraparound) : \
402
    __Pyx_DelItem_Generic(o, to_py_func(i)))
403

404 405 406 407 408 409
static CYTHON_INLINE int __Pyx_DelItem_Generic(PyObject *o, PyObject *j);
static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i,
                                               CYTHON_UNUSED int is_list, int wraparound);

/////////////// DelItemInt ///////////////

410 411 412 413 414 415 416 417
static CYTHON_INLINE int __Pyx_DelItem_Generic(PyObject *o, PyObject *j) {
    int r;
    if (!j) return -1;
    r = PyObject_DelItem(o, j);
    Py_DECREF(j);
    return r;
}

418
static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i,
419
                                               CYTHON_UNUSED int is_list, int wraparound) {
420
#if CYTHON_COMPILING_IN_PYPY
421
    if (is_list || PySequence_Check(o)) {
422 423 424
        return PySequence_DelItem(o, i);
    }
#else
425
    // inlined PySequence_DelItem() + special cased length overflow
426 427
    PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
    if (likely(m && m->sq_ass_item)) {
428
        if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
429
            Py_ssize_t l = m->sq_length(o);
Stefan Behnel's avatar
Stefan Behnel committed
430 431 432 433 434 435 436 437 438
            if (likely(l >= 0)) {
                i += l;
            } else {
                // if length > max(Py_ssize_t), maybe the object can wrap around itself?
                if (PyErr_ExceptionMatches(PyExc_OverflowError))
                    PyErr_Clear();
                else
                    return -1;
            }
439 440 441 442 443 444 445
        }
        return m->sq_ass_item(o, i, (PyObject *)NULL);
    }
#endif
    return __Pyx_DelItem_Generic(o, PyInt_FromSsize_t(i));
}

446

447
/////////////// SliceObject.proto ///////////////
448 449

// we pass pointer addresses to show the C compiler what is NULL and what isn't
450 451
{{if access == 'Get'}}
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(
452 453
        PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop,
        PyObject** py_start, PyObject** py_stop, PyObject** py_slice,
454
        int has_cstart, int has_cstop, int wraparound);
455
{{else}}
456 457
#define __Pyx_PyObject_DelSlice(obj, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound) \
    __Pyx_PyObject_SetSlice(obj, (PyObject*)NULL, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound)
458 459

// we pass pointer addresses to show the C compiler what is NULL and what isn't
460
static CYTHON_INLINE int __Pyx_PyObject_SetSlice(
461 462
        PyObject* obj, PyObject* value, Py_ssize_t cstart, Py_ssize_t cstop,
        PyObject** py_start, PyObject** py_stop, PyObject** py_slice,
463
        int has_cstart, int has_cstop, int wraparound);
464
{{endif}}
465

466
/////////////// SliceObject ///////////////
467

468 469 470 471 472
{{if access == 'Get'}}
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(
        PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop,
{{else}}
static CYTHON_INLINE int __Pyx_PyObject_SetSlice(
473
        PyObject* obj, PyObject* value, Py_ssize_t cstart, Py_ssize_t cstop,
474
{{endif}}
475
        PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice,
476
        int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) {
Stefan Behnel's avatar
Stefan Behnel committed
477
#if CYTHON_COMPILING_IN_CPYTHON
478 479 480
    PyMappingMethods* mp;
#if PY_MAJOR_VERSION < 3
    PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence;
481
    if (likely(ms && ms->sq_{{if access == 'Set'}}ass_{{endif}}slice)) {
482
        if (!has_cstart) {
483
            if (_py_start && (*_py_start != Py_None)) {
484
                cstart = __Pyx_PyIndex_AsSsize_t(*_py_start);
485
                if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
486 487 488 489
            } else
                cstart = 0;
        }
        if (!has_cstop) {
490
            if (_py_stop && (*_py_stop != Py_None)) {
491
                cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop);
492
                if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
493 494 495
            } else
                cstop = PY_SSIZE_T_MAX;
        }
496
        if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) {
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
            Py_ssize_t l = ms->sq_length(obj);
            if (likely(l >= 0)) {
                if (cstop < 0) {
                    cstop += l;
                    if (cstop < 0) cstop = 0;
                }
                if (cstart < 0) {
                    cstart += l;
                    if (cstart < 0) cstart = 0;
                }
            } else {
                // if length > max(Py_ssize_t), maybe the object can wrap around itself?
                if (PyErr_ExceptionMatches(PyExc_OverflowError))
                    PyErr_Clear();
                else
512
                    goto bad;
513 514
            }
        }
515 516 517
{{if access == 'Get'}}
        return ms->sq_slice(obj, cstart, cstop);
{{else}}
518
        return ms->sq_ass_slice(obj, cstart, cstop, value);
519
{{endif}}
520 521
    }
#endif
522

523
    mp = Py_TYPE(obj)->tp_as_mapping;
524
{{if access == 'Get'}}
Stefan Behnel's avatar
Stefan Behnel committed
525
    if (likely(mp && mp->mp_subscript))
526
{{else}}
Stefan Behnel's avatar
Stefan Behnel committed
527
    if (likely(mp && mp->mp_ass_subscript))
528
{{endif}}
Stefan Behnel's avatar
Stefan Behnel committed
529 530 531
#endif
    {
        {{if access == 'Get'}}PyObject*{{else}}int{{endif}} result;
532
        PyObject *py_slice, *py_start, *py_stop;
533 534 535 536 537 538 539 540 541 542
        if (_py_slice) {
            py_slice = *_py_slice;
        } else {
            PyObject* owned_start = NULL;
            PyObject* owned_stop = NULL;
            if (_py_start) {
                py_start = *_py_start;
            } else {
                if (has_cstart) {
                    owned_start = py_start = PyInt_FromSsize_t(cstart);
543
                    if (unlikely(!py_start)) goto bad;
544 545 546 547 548 549 550 551 552 553
                } else
                    py_start = Py_None;
            }
            if (_py_stop) {
                py_stop = *_py_stop;
            } else {
                if (has_cstop) {
                    owned_stop = py_stop = PyInt_FromSsize_t(cstop);
                    if (unlikely(!py_stop)) {
                        Py_XDECREF(owned_start);
554
                        goto bad;
555 556 557 558 559 560 561
                    }
                } else
                    py_stop = Py_None;
            }
            py_slice = PySlice_New(py_start, py_stop, Py_None);
            Py_XDECREF(owned_start);
            Py_XDECREF(owned_stop);
562
            if (unlikely(!py_slice)) goto bad;
563
        }
Stefan Behnel's avatar
Stefan Behnel committed
564
#if CYTHON_COMPILING_IN_CPYTHON
565 566
{{if access == 'Get'}}
        result = mp->mp_subscript(obj, py_slice);
Stefan Behnel's avatar
Stefan Behnel committed
567 568
#else
        result = PyObject_GetItem(obj, py_slice);
569
{{else}}
570
        result = mp->mp_ass_subscript(obj, py_slice, value);
Stefan Behnel's avatar
Stefan Behnel committed
571 572
#else
        result = value ? PyObject_SetItem(obj, py_slice, value) : PyObject_DelItem(obj, py_slice);
573
{{endif}}
Stefan Behnel's avatar
Stefan Behnel committed
574
#endif
575 576 577 578 579 580
        if (!_py_slice) {
            Py_DECREF(py_slice);
        }
        return result;
    }
    PyErr_Format(PyExc_TypeError,
581
{{if access == 'Get'}}
582
        "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name);
583
{{else}}
584 585
        "'%.200s' object does not support slice %s",
        Py_TYPE(obj)->tp_name, value ? "assignment" : "deletion");
586 587 588 589
{{endif}}

bad:
    return {{if access == 'Get'}}NULL{{else}}-1{{endif}};
590 591
}

592

593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623
/////////////// SliceTupleAndList.proto ///////////////

#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop);
static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop);
#else
#define __Pyx_PyList_GetSlice(seq, start, stop)   PySequence_GetSlice(seq, start, stop)
#define __Pyx_PyTuple_GetSlice(seq, start, stop)  PySequence_GetSlice(seq, start, stop)
#endif

/////////////// SliceTupleAndList ///////////////

#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE void __Pyx_crop_slice(Py_ssize_t* _start, Py_ssize_t* _stop, Py_ssize_t* _length) {
    Py_ssize_t start = *_start, stop = *_stop, length = *_length;
    if (start < 0) {
        start += length;
        if (start < 0)
            start = 0;
    }

    if (stop < 0)
        stop += length;
    else if (stop > length)
        stop = length;

    *_length = stop - start;
    *_start = start;
    *_stop = stop;
}

Stefan Behnel's avatar
Stefan Behnel committed
624
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
Stefan Behnel's avatar
Stefan Behnel committed
625
static CYTHON_INLINE void __Pyx_copy_object_array(PyObject** restrict src, PyObject** restrict dest, Py_ssize_t length) {
626
#else
Stefan Behnel's avatar
Stefan Behnel committed
627
static CYTHON_INLINE void __Pyx_copy_object_array(PyObject** src, PyObject** dest, Py_ssize_t length) {
628 629 630 631 632 633 634 635 636
#endif
    PyObject *v;
    Py_ssize_t i;
    for (i = 0; i < length; i++) {
        v = dest[i] = src[i];
        Py_INCREF(v);
    }
}

637 638
{{for type in ['List', 'Tuple']}}
static CYTHON_INLINE PyObject* __Pyx_Py{{type}}_GetSlice(
639 640
            PyObject* src, Py_ssize_t start, Py_ssize_t stop) {
    PyObject* dest;
641
    Py_ssize_t length = Py{{type}}_GET_SIZE(src);
642 643
    __Pyx_crop_slice(&start, &stop, &length);
    if (unlikely(length <= 0))
644
        return Py{{type}}_New(0);
645

646
    dest = Py{{type}}_New(length);
647 648
    if (unlikely(!dest))
        return NULL;
Stefan Behnel's avatar
Stefan Behnel committed
649
    __Pyx_copy_object_array(
650 651
        ((Py{{type}}Object*)src)->ob_item + start,
        ((Py{{type}}Object*)dest)->ob_item,
652 653 654
        length);
    return dest;
}
655
{{endfor}}
656 657
#endif

658 659 660 661 662
/////////////// FindPy2Metaclass.proto ///////////////

static PyObject *__Pyx_FindPy2Metaclass(PyObject *bases); /*proto*/

/////////////// FindPy2Metaclass ///////////////
663
//@requires: PyObjectGetAttrStr
664 665 666 667 668 669 670

static PyObject *__Pyx_FindPy2Metaclass(PyObject *bases) {
    PyObject *metaclass;
    /* Default metaclass */
#if PY_MAJOR_VERSION < 3
    if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
        PyObject *base = PyTuple_GET_ITEM(bases, 0);
671
        metaclass = __Pyx_PyObject_GetAttrStr(base, PYIDENT("__class__"));
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
        if (!metaclass) {
            PyErr_Clear();
            metaclass = (PyObject*) Py_TYPE(base);
        }
    } else {
        metaclass = (PyObject *) &PyClass_Type;
    }
#else
    if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
        PyObject *base = PyTuple_GET_ITEM(bases, 0);
        metaclass = (PyObject*) Py_TYPE(base);
    } else {
        metaclass = (PyObject *) &PyType_Type;
    }
#endif
    Py_INCREF(metaclass);
    return metaclass;
}

/////////////// Py3MetaclassGet.proto ///////////////

static PyObject *__Pyx_Py3MetaclassGet(PyObject *bases, PyObject *mkw); /*proto*/

/////////////// Py3MetaclassGet ///////////////
//@requires: FindPy2Metaclass

static PyObject *__Pyx_Py3MetaclassGet(PyObject *bases, PyObject *mkw) {
699
    PyObject *metaclass = PyDict_GetItem(mkw, PYIDENT("metaclass"));
700 701
    if (metaclass) {
        Py_INCREF(metaclass);
702
        if (PyDict_DelItem(mkw, PYIDENT("metaclass")) < 0) {
703 704 705 706 707 708 709 710 711 712 713
            Py_DECREF(metaclass);
            return NULL;
        }
        return metaclass;
    }
    return __Pyx_FindPy2Metaclass(bases);
}

/////////////// CreateClass.proto ///////////////

static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name,
714
                                   PyObject *qualname, PyObject *modname); /*proto*/
715 716 717 718 719

/////////////// CreateClass ///////////////
//@requires: FindPy2Metaclass

static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name,
720
                                   PyObject *qualname, PyObject *modname) {
721 722 723
    PyObject *result;
    PyObject *metaclass;

724
    if (PyDict_SetItem(dict, PYIDENT("__module__"), modname) < 0)
725
        return NULL;
726
    if (PyDict_SetItem(dict, PYIDENT("__qualname__"), qualname) < 0)
727
        return NULL;
728 729

    /* Python2 __metaclass__ */
730
    metaclass = PyDict_GetItem(dict, PYIDENT("__metaclass__"));
731 732 733 734 735 736 737 738 739 740 741 742
    if (metaclass) {
        Py_INCREF(metaclass);
    } else {
        metaclass = __Pyx_FindPy2Metaclass(bases);
    }
    result = PyObject_CallFunctionObjArgs(metaclass, name, bases, dict, NULL);
    Py_DECREF(metaclass);
    return result;
}

/////////////// Py3ClassCreate.proto ///////////////

743
static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc); /*proto*/
744 745 746
static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, PyObject *mkw); /*proto*/

/////////////// Py3ClassCreate ///////////////
747
//@requires: PyObjectGetAttrStr
748 749

static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name,
750
                                           PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) {
751 752 753 754
    PyObject *prep;
    PyObject *pargs;
    PyObject *ns;

755
    prep = __Pyx_PyObject_GetAttrStr(metaclass, PYIDENT("__prepare__"));
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774
    if (!prep) {
        if (!PyErr_ExceptionMatches(PyExc_AttributeError))
            return NULL;
        PyErr_Clear();
        return PyDict_New();
    }
    pargs = PyTuple_Pack(2, name, bases);
    if (!pargs) {
        Py_DECREF(prep);
        return NULL;
    }
    ns = PyObject_Call(prep, pargs, mkw);
    Py_DECREF(prep);
    Py_DECREF(pargs);

    if (ns == NULL)
        return NULL;

    /* Required here to emulate assignment order */
775 776 777
    if (PyObject_SetItem(ns, PYIDENT("__module__"), modname) < 0) goto bad;
    if (PyObject_SetItem(ns, PYIDENT("__qualname__"), qualname) < 0) goto bad;
    if (doc && PyObject_SetItem(ns, PYIDENT("__doc__"), doc) < 0) goto bad;
778
    return ns;
779 780 781
bad:
    Py_DECREF(ns);
    return NULL;
782 783 784 785 786 787 788 789 790 791 792 793
}

static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases,
                                      PyObject *dict, PyObject *mkw) {
    PyObject *result;
    PyObject *margs = PyTuple_Pack(3, name, bases, dict);
    if (!margs)
        return NULL;
    result = PyObject_Call(metaclass, margs, mkw);
    Py_DECREF(margs);
    return result;
}
794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811

/////////////// ExtTypeTest.proto ///////////////

static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/

/////////////// ExtTypeTest ///////////////

static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
    if (unlikely(!type)) {
        PyErr_Format(PyExc_SystemError, "Missing type object");
        return 0;
    }
    if (likely(PyObject_TypeCheck(obj, type)))
        return 1;
    PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
                 Py_TYPE(obj)->tp_name, type->tp_name);
    return 0;
}
812 813 814

/////////////// CallableCheck.proto ///////////////

815
#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
816 817 818 819
#define __Pyx_PyCallable_Check(obj)   ((obj)->ob_type->tp_call != NULL)
#else
#define __Pyx_PyCallable_Check(obj)   PyCallable_Check(obj)
#endif
820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839

/////////////// PyDictContains.proto ///////////////

static CYTHON_INLINE int __Pyx_PyDict_Contains(PyObject* item, PyObject* dict, int eq) {
    int result = PyDict_Contains(dict, item);
    return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
}

/////////////// PySequenceContains.proto ///////////////

static CYTHON_INLINE int __Pyx_PySequence_Contains(PyObject* item, PyObject* seq, int eq) {
    int result = PySequence_Contains(seq, item);
    return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
}

/////////////// PyBoolOrNullFromLong.proto ///////////////

static CYTHON_INLINE PyObject* __Pyx_PyBoolOrNull_FromLong(long b) {
    return unlikely(b < 0) ? NULL : __Pyx_PyBool_FromLong(b);
}
840

841
/////////////// GetBuiltinName.proto ///////////////
842

843
static PyObject *__Pyx_GetBuiltinName(PyObject *name); /*proto*/
844

845
/////////////// GetBuiltinName ///////////////
846 847 848
//@requires: PyObjectGetAttrStr
//@substitute: naming

849 850 851 852
static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
    PyObject* result = __Pyx_PyObject_GetAttrStr($builtins_cname, name);
    if (unlikely(!result)) {
        PyErr_Format(PyExc_NameError,
853
#if PY_MAJOR_VERSION >= 3
854
            "name '%U' is not defined", name);
855
#else
856
            "name '%s' is not defined", PyString_AS_STRING(name));
857 858 859 860 861
#endif
    }
    return result;
}

862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877
/////////////// GetNameInClass.proto ///////////////

static PyObject *__Pyx_GetNameInClass(PyObject *nmspace, PyObject *name); /*proto*/

/////////////// GetNameInClass ///////////////
//@requires: PyObjectGetAttrStr
//@requires: GetModuleGlobalName

static PyObject *__Pyx_GetNameInClass(PyObject *nmspace, PyObject *name) {
    PyObject *result;
    result = __Pyx_PyObject_GetAttrStr(nmspace, name);
    if (!result)
        result = __Pyx_GetModuleGlobalName(name);
    return result;
}

878 879 880 881 882
/////////////// GetModuleGlobalName.proto ///////////////

static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); /*proto*/

/////////////// GetModuleGlobalName ///////////////
883
//@requires: GetBuiltinName
884 885 886 887 888 889 890 891 892 893 894 895 896 897
//@substitute: naming

static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
    PyObject *result;
#if CYTHON_COMPILING_IN_CPYTHON
    result = PyDict_GetItem($moddict_cname, name);
    if (result) {
        Py_INCREF(result);
    } else {
#else
    result = PyObject_GetItem($moddict_cname, name);
    if (!result) {
        PyErr_Clear();
#endif
898
        result = __Pyx_GetBuiltinName(name);
899 900 901 902
    }
    return result;
}

903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
/////////////// PyObjectGetAttrStr.proto ///////////////

#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_getattro))
        return tp->tp_getattro(obj, attr_name);
#if PY_MAJOR_VERSION < 3
    if (likely(tp->tp_getattr))
        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
#endif
    return PyObject_GetAttr(obj, attr_name);
}
#else
#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
#endif

920 921 922
/////////////// PyObjectSetAttrStr.proto ///////////////

#if CYTHON_COMPILING_IN_CPYTHON
923
#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL)
924 925 926 927 928 929 930 931 932 933 934
static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_setattro))
        return tp->tp_setattro(obj, attr_name, value);
#if PY_MAJOR_VERSION < 3
    if (likely(tp->tp_setattr))
        return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value);
#endif
    return PyObject_SetAttr(obj, attr_name, value);
}
#else
935
#define __Pyx_PyObject_DelAttrStr(o,n)   PyObject_DelAttr(o,n)
936 937 938
#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v)
#endif

939
/////////////// PyObjectCallMethod.proto ///////////////
940
//@requires: PyObjectGetAttrStr
941 942 943 944 945
//@substitute: naming

static PyObject* __Pyx_PyObject_CallMethodTuple(PyObject* obj, PyObject* method_name, PyObject* args) {
    PyObject *method, *result = NULL;
    if (unlikely(!args)) return NULL;
946
    method = __Pyx_PyObject_GetAttrStr(obj, method_name);
947 948 949 950 951 952 953 954 955
    if (unlikely(!method)) goto bad;
    result = PyObject_Call(method, args, NULL);
    Py_DECREF(method);
bad:
    Py_DECREF(args);
    return result;
}

#define __Pyx_PyObject_CallMethod3(obj, name, arg1, arg2, arg3) \
956
    __Pyx_PyObject_CallMethodTuple(obj, name, PyTuple_Pack(3, arg1, arg2, arg3))
957
#define __Pyx_PyObject_CallMethod2(obj, name, arg1, arg2) \
958
    __Pyx_PyObject_CallMethodTuple(obj, name, PyTuple_Pack(2, arg1, arg2))
959
#define __Pyx_PyObject_CallMethod1(obj, name, arg1) \
960
    __Pyx_PyObject_CallMethodTuple(obj, name, PyTuple_Pack(1, arg1))
961
#define __Pyx_PyObject_CallMethod0(obj, name) \
962
    __Pyx_PyObject_CallMethodTuple(obj, name, (Py_INCREF($empty_tuple), $empty_tuple))
963 964 965 966


/////////////// tp_new.proto ///////////////

967 968
#define __Pyx_tp_new(type_obj, args) __Pyx_tp_new_kwargs(type_obj, args, NULL)
static CYTHON_INLINE PyObject* __Pyx_tp_new_kwargs(PyObject* type_obj, PyObject* args, PyObject* kwargs) {
Stefan Behnel's avatar
Stefan Behnel committed
969
    return (PyObject*) (((PyTypeObject*)type_obj)->tp_new((PyTypeObject*)type_obj, args, kwargs));
970
}