src/third_party/cython/src/Cython/Utility/ObjectHandling.c

   1 /*
   2  * General object operations and protocol implementations,
   3  * including their specialisations for certain builtins.
   4  *
   5  * Optional optimisations for builtins are in Optimize.c.
   6  *
   7  * Required replacements of builtins are in Builtins.c.
   8  */
   9
  10 /////////////// RaiseNoneIterError.proto ///////////////
  11
  12 static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
  13
  14 /////////////// RaiseNoneIterError ///////////////
  15
  16 static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
  17     PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
  18 }
  19
  20 /////////////// RaiseTooManyValuesToUnpack.proto ///////////////
  21
  22 static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
  23
  24 /////////////// RaiseTooManyValuesToUnpack ///////////////
  25
  26 static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
  27     PyErr_Format(PyExc_ValueError,
  28                  "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
  29 }
  30
  31 /////////////// RaiseNeedMoreValuesToUnpack.proto ///////////////
  32
  33 static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
  34
  35 /////////////// RaiseNeedMoreValuesToUnpack ///////////////
  36
  37 static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
  38     PyErr_Format(PyExc_ValueError,
  39                  "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
  40                  index, (index == 1) ? "" : "s");
  41 }
  42
  43 /////////////// UnpackTupleError.proto ///////////////
  44
  45 static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /*proto*/
  46
  47 /////////////// UnpackTupleError ///////////////
  48 //@requires: RaiseNoneIterError
  49 //@requires: RaiseNeedMoreValuesToUnpack
  50 //@requires: RaiseTooManyValuesToUnpack
  51
  52 static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
  53     if (t == Py_None) {
  54       __Pyx_RaiseNoneNotIterableError();
  55     } else if (PyTuple_GET_SIZE(t) < index) {
  56       __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t));
  57     } else {
  58       __Pyx_RaiseTooManyValuesError(index);
  59     }
  60 }
  61
  62 /////////////// UnpackItemEndCheck.proto ///////////////
  63
  64 static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /*proto*/
  65
  66 /////////////// UnpackItemEndCheck ///////////////
  67 //@requires: RaiseTooManyValuesToUnpack
  68 //@requires: IterFinish
  69
  70 static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
  71     if (unlikely(retval)) {
  72         Py_DECREF(retval);
  73         __Pyx_RaiseTooManyValuesError(expected);
  74         return -1;
  75     } else {
  76         return __Pyx_IterFinish();
  77     }
  78     return 0;
  79 }
  80
  81 /////////////// UnpackTuple2.proto ///////////////
  82
  83 static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** value1, PyObject** value2,
  84                                              int is_tuple, int has_known_size, int decref_tuple);
  85
  86 /////////////// UnpackTuple2 ///////////////
  87 //@requires: UnpackItemEndCheck
  88 //@requires: UnpackTupleError
  89 //@requires: RaiseNeedMoreValuesToUnpack
  90
  91 static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2,
  92                                              int is_tuple, int has_known_size, int decref_tuple) {
  93     Py_ssize_t index;
  94     PyObject *value1 = NULL, *value2 = NULL, *iter = NULL;
  95     if (!is_tuple && unlikely(!PyTuple_Check(tuple))) {
  96         iternextfunc iternext;
  97         iter = PyObject_GetIter(tuple);
  98         if (unlikely(!iter)) goto bad;
  99         if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; }
 100         iternext = Py_TYPE(iter)->tp_iternext;
 101         value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; }
 102         value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; }
 103         if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad;
 104         Py_DECREF(iter);
 105     } else {
 106         if (!has_known_size && unlikely(PyTuple_GET_SIZE(tuple) != 2)) {
 107             __Pyx_UnpackTupleError(tuple, 2);
 108             goto bad;
 109         }
 110 #if CYTHON_COMPILING_IN_PYPY
 111         value1 = PySequence_ITEM(tuple, 0);
 112         if (unlikely(!value1)) goto bad;
 113         value2 = PySequence_ITEM(tuple, 1);
 114         if (unlikely(!value2)) goto bad;
 115 #else
 116         value1 = PyTuple_GET_ITEM(tuple, 0);
 117         value2 = PyTuple_GET_ITEM(tuple, 1);
 118         Py_INCREF(value1);
 119         Py_INCREF(value2);
 120 #endif
 121         if (decref_tuple) { Py_DECREF(tuple); }
 122     }
 123     *pvalue1 = value1;
 124     *pvalue2 = value2;
 125     return 0;
 126 unpacking_failed:
 127     if (!has_known_size && __Pyx_IterFinish() == 0)
 128         __Pyx_RaiseNeedMoreValuesError(index);
 129 bad:
 130     Py_XDECREF(iter);
 131     Py_XDECREF(value1);
 132     Py_XDECREF(value2);
 133     if (decref_tuple) { Py_XDECREF(tuple); }
 134     return -1;
 135 }
 136
 137 /////////////// IterNext.proto ///////////////
 138
 139 #define __Pyx_PyIter_Next(obj) __Pyx_PyIter_Next2(obj, NULL)
 140 static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *); /*proto*/
 141
 142 /////////////// IterNext ///////////////
 143
 144 // originally copied from Py3's builtin_next()
 145 static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject* iterator, PyObject* defval) {
 146     PyObject* next;
 147     iternextfunc iternext = Py_TYPE(iterator)->tp_iternext;
 148 #if CYTHON_COMPILING_IN_CPYTHON
 149     if (unlikely(!iternext)) {
 150 #else
 151     if (unlikely(!iternext) || unlikely(!PyIter_Check(iterator))) {
 152 #endif
 153         PyErr_Format(PyExc_TypeError,
 154             "%.200s object is not an iterator", Py_TYPE(iterator)->tp_name);
 155         return NULL;
 156     }
 157     next = iternext(iterator);
 158     if (likely(next))
 159         return next;
 160 #if CYTHON_COMPILING_IN_CPYTHON
 161 #if PY_VERSION_HEX >= 0x03010000 || (PY_MAJOR_VERSION < 3 && PY_VERSION_HEX >= 0x02070000)
 162     if (unlikely(iternext == &_PyObject_NextNotImplemented))
 163         return NULL;
 164 #endif
 165 #endif
 166     if (defval) {
 167         PyObject* exc_type = PyErr_Occurred();
 168         if (exc_type) {
 169             if (unlikely(exc_type != PyExc_StopIteration) &&
 170                     !PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))
 171                 return NULL;
 172             PyErr_Clear();
 173         }
 174         Py_INCREF(defval);
 175         return defval;
 176     }
 177     if (!PyErr_Occurred())
 178         PyErr_SetNone(PyExc_StopIteration);
 179     return NULL;
 180 }
 181
 182 /////////////// IterFinish.proto ///////////////
 183
 184 static CYTHON_INLINE int __Pyx_IterFinish(void); /*proto*/
 185
 186 /////////////// IterFinish ///////////////
 187
 188 // When PyIter_Next(iter) has returned NULL in order to signal termination,
 189 // this function does the right cleanup and returns 0 on success.  If it
 190 // detects an error that occurred in the iterator, it returns -1.
 191
 192 static CYTHON_INLINE int __Pyx_IterFinish(void) {
 193 #if CYTHON_COMPILING_IN_CPYTHON
 194     PyThreadState *tstate = PyThreadState_GET();
 195     PyObject* exc_type = tstate->curexc_type;
 196     if (unlikely(exc_type)) {
 197         if (likely(exc_type == PyExc_StopIteration) || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)) {
 198             PyObject *exc_value, *exc_tb;
 199             exc_value = tstate->curexc_value;
 200             exc_tb = tstate->curexc_traceback;
 201             tstate->curexc_type = 0;
 202             tstate->curexc_value = 0;
 203             tstate->curexc_traceback = 0;
 204             Py_DECREF(exc_type);
 205             Py_XDECREF(exc_value);
 206             Py_XDECREF(exc_tb);
 207             return 0;
 208         } else {
 209             return -1;
 210         }
 211     }
 212     return 0;
 213 #else
 214     if (unlikely(PyErr_Occurred())) {
 215         if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
 216             PyErr_Clear();
 217             return 0;
 218         } else {
 219             return -1;
 220         }
 221     }
 222     return 0;
 223 #endif
 224 }
 225
 226 /////////////// DictGetItem.proto ///////////////
 227
 228 #if PY_MAJOR_VERSION >= 3
 229 static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
 230     PyObject *value;
 231     value = PyDict_GetItemWithError(d, key);
 232     if (unlikely(!value)) {
 233         if (!PyErr_Occurred()) {
 234             PyObject* args = PyTuple_Pack(1, key);
 235             if (likely(args))
 236                 PyErr_SetObject(PyExc_KeyError, args);
 237             Py_XDECREF(args);
 238         }
 239         return NULL;
 240     }
 241     Py_INCREF(value);
 242     return value;
 243 }
 244 #else
 245     #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
 246 #endif
 247
 248 /////////////// GetItemInt.proto ///////////////
 249
 250 #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \
 251     (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \
 252     __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) : \
 253     (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) : \
 254                __Pyx_GetItemInt_Generic(o, to_py_func(i))))
 255
 256 {{for type in ['List', 'Tuple']}}
 257 #define __Pyx_GetItemInt_{{type}}(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \
 258     (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \
 259     __Pyx_GetItemInt_{{type}}_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) : \
 260     (PyErr_SetString(PyExc_IndexError, "{{ type.lower() }} index out of range"), (PyObject*)NULL))
 261
 262 static CYTHON_INLINE PyObject *__Pyx_GetItemInt_{{type}}_Fast(PyObject *o, Py_ssize_t i,
 263                                                               int wraparound, int boundscheck);
 264 {{endfor}}
 265
 266 static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
 267 static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
 268                                                      int is_list, int wraparound, int boundscheck);
 269
 270 /////////////// GetItemInt ///////////////
 271
 272 static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
 273     PyObject *r;
 274     if (!j) return NULL;
 275     r = PyObject_GetItem(o, j);
 276     Py_DECREF(j);
 277     return r;
 278 }
 279
 280 {{for type in ['List', 'Tuple']}}
 281 static CYTHON_INLINE PyObject *__Pyx_GetItemInt_{{type}}_Fast(PyObject *o, Py_ssize_t i,
 282                                                               int wraparound, int boundscheck) {
 283 #if CYTHON_COMPILING_IN_CPYTHON
 284     if (wraparound & unlikely(i < 0)) i += Py{{type}}_GET_SIZE(o);
 285     if ((!boundscheck) || likely((0 <= i) & (i < Py{{type}}_GET_SIZE(o)))) {
 286         PyObject *r = Py{{type}}_GET_ITEM(o, i);
 287         Py_INCREF(r);
 288         return r;
 289     }
 290     return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
 291 #else
 292     return PySequence_GetItem(o, i);
 293 #endif
 294 }
 295 {{endfor}}
 296
 297 static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
 298                                                      int is_list, int wraparound, int boundscheck) {
 299 #if CYTHON_COMPILING_IN_CPYTHON
 300     if (is_list || PyList_CheckExact(o)) {
 301         Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
 302         if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) {
 303             PyObject *r = PyList_GET_ITEM(o, n);
 304             Py_INCREF(r);
 305             return r;
 306         }
 307     }
 308     else if (PyTuple_CheckExact(o)) {
 309         Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
 310         if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) {
 311             PyObject *r = PyTuple_GET_ITEM(o, n);
 312             Py_INCREF(r);
 313             return r;
 314         }
 315     } else {
 316         // inlined PySequence_GetItem() + special cased length overflow
 317         PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
 318         if (likely(m && m->sq_item)) {
 319             if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
 320                 Py_ssize_t l = m->sq_length(o);
 321                 if (likely(l >= 0)) {
 322                     i += l;
 323                 } else {
 324                     // if length > max(Py_ssize_t), maybe the object can wrap around itself?
 325                     if (PyErr_ExceptionMatches(PyExc_OverflowError))
 326                         PyErr_Clear();
 327                     else
 328                         return NULL;
 329                 }
 330             }
 331             return m->sq_item(o, i);
 332         }
 333     }
 334 #else
 335     if (is_list || PySequence_Check(o)) {
 336         return PySequence_GetItem(o, i);
 337     }
 338 #endif
 339     return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
 340 }
 341
 342 /////////////// SetItemInt.proto ///////////////
 343
 344 #define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \
 345     (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \
 346     __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) : \
 347     (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) : \
 348                __Pyx_SetItemInt_Generic(o, to_py_func(i), v)))
 349
 350 static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v);
 351 static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
 352                                                int is_list, int wraparound, int boundscheck);
 353
 354 /////////////// SetItemInt ///////////////
 355
 356 static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
 357     int r;
 358     if (!j) return -1;
 359     r = PyObject_SetItem(o, j, v);
 360     Py_DECREF(j);
 361     return r;
 362 }
 363
 364 static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
 365                                                int is_list, int wraparound, int boundscheck) {
 366 #if CYTHON_COMPILING_IN_CPYTHON
 367     if (is_list || PyList_CheckExact(o)) {
 368         Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o));
 369         if ((!boundscheck) || likely((n >= 0) & (n < PyList_GET_SIZE(o)))) {
 370             PyObject* old = PyList_GET_ITEM(o, n);
 371             Py_INCREF(v);
 372             PyList_SET_ITEM(o, n, v);
 373             Py_DECREF(old);
 374             return 1;
 375         }
 376     } else {
 377         // inlined PySequence_SetItem() + special cased length overflow
 378         PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
 379         if (likely(m && m->sq_ass_item)) {
 380             if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
 381                 Py_ssize_t l = m->sq_length(o);
 382                 if (likely(l >= 0)) {
 383                     i += l;
 384                 } else {
 385                     // if length > max(Py_ssize_t), maybe the object can wrap around itself?
 386                     if (PyErr_ExceptionMatches(PyExc_OverflowError))
 387                         PyErr_Clear();
 388                     else
 389                         return -1;
 390                 }
 391             }
 392             return m->sq_ass_item(o, i, v);
 393         }
 394     }
 395 #else
 396 #if CYTHON_COMPILING_IN_PYPY
 397     if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) {
 398 #else
 399     if (is_list || PySequence_Check(o)) {
 400 #endif
 401         return PySequence_SetItem(o, i, v);
 402     }
 403 #endif
 404     return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
 405 }
 406
 407
 408 /////////////// DelItemInt.proto ///////////////
 409
 410 #define __Pyx_DelItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck) \
 411     (__Pyx_fits_Py_ssize_t(i, type, is_signed) ? \
 412     __Pyx_DelItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound) : \
 413     (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) : \
 414                __Pyx_DelItem_Generic(o, to_py_func(i))))
 415
 416 static CYTHON_INLINE int __Pyx_DelItem_Generic(PyObject *o, PyObject *j);
 417 static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i,
 418                                                CYTHON_UNUSED int is_list, int wraparound);
 419
 420 /////////////// DelItemInt ///////////////
 421
 422 static CYTHON_INLINE int __Pyx_DelItem_Generic(PyObject *o, PyObject *j) {
 423     int r;
 424     if (!j) return -1;
 425     r = PyObject_DelItem(o, j);
 426     Py_DECREF(j);
 427     return r;
 428 }
 429
 430 static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i,
 431                                                CYTHON_UNUSED int is_list, int wraparound) {
 432 #if CYTHON_COMPILING_IN_PYPY
 433     if (is_list || PySequence_Check(o)) {
 434         return PySequence_DelItem(o, i);
 435     }
 436 #else
 437     // inlined PySequence_DelItem() + special cased length overflow
 438     PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
 439     if (likely(m && m->sq_ass_item)) {
 440         if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
 441             Py_ssize_t l = m->sq_length(o);
 442             if (likely(l >= 0)) {
 443                 i += l;
 444             } else {
 445                 // if length > max(Py_ssize_t), maybe the object can wrap around itself?
 446                 if (PyErr_ExceptionMatches(PyExc_OverflowError))
 447                     PyErr_Clear();
 448                 else
 449                     return -1;
 450             }
 451         }
 452         return m->sq_ass_item(o, i, (PyObject *)NULL);
 453     }
 454 #endif
 455     return __Pyx_DelItem_Generic(o, PyInt_FromSsize_t(i));
 456 }
 457
 458
 459 /////////////// SliceObject.proto ///////////////
 460
 461 // we pass pointer addresses to show the C compiler what is NULL and what isn't
 462 {{if access == 'Get'}}
 463 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(
 464         PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop,
 465         PyObject** py_start, PyObject** py_stop, PyObject** py_slice,
 466         int has_cstart, int has_cstop, int wraparound);
 467 {{else}}
 468 #define __Pyx_PyObject_DelSlice(obj, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound) \
 469     __Pyx_PyObject_SetSlice(obj, (PyObject*)NULL, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound)
 470
 471 // we pass pointer addresses to show the C compiler what is NULL and what isn't
 472 static CYTHON_INLINE int __Pyx_PyObject_SetSlice(
 473         PyObject* obj, PyObject* value, Py_ssize_t cstart, Py_ssize_t cstop,
 474         PyObject** py_start, PyObject** py_stop, PyObject** py_slice,
 475         int has_cstart, int has_cstop, int wraparound);
 476 {{endif}}
 477
 478 /////////////// SliceObject ///////////////
 479
 480 {{if access == 'Get'}}
 481 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(
 482         PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop,
 483 {{else}}
 484 static CYTHON_INLINE int __Pyx_PyObject_SetSlice(
 485         PyObject* obj, PyObject* value, Py_ssize_t cstart, Py_ssize_t cstop,
 486 {{endif}}
 487         PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice,
 488         int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) {
 489 #if CYTHON_COMPILING_IN_CPYTHON
 490     PyMappingMethods* mp;
 491 #if PY_MAJOR_VERSION < 3
 492     PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence;
 493     if (likely(ms && ms->sq_{{if access == 'Set'}}ass_{{endif}}slice)) {
 494         if (!has_cstart) {
 495             if (_py_start && (*_py_start != Py_None)) {
 496                 cstart = __Pyx_PyIndex_AsSsize_t(*_py_start);
 497                 if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
 498             } else
 499                 cstart = 0;
 500         }
 501         if (!has_cstop) {
 502             if (_py_stop && (*_py_stop != Py_None)) {
 503                 cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop);
 504                 if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad;
 505             } else
 506                 cstop = PY_SSIZE_T_MAX;
 507         }
 508         if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) {
 509             Py_ssize_t l = ms->sq_length(obj);
 510             if (likely(l >= 0)) {
 511                 if (cstop < 0) {
 512                     cstop += l;
 513                     if (cstop < 0) cstop = 0;
 514                 }
 515                 if (cstart < 0) {
 516                     cstart += l;
 517                     if (cstart < 0) cstart = 0;
 518                 }
 519             } else {
 520                 // if length > max(Py_ssize_t), maybe the object can wrap around itself?
 521                 if (PyErr_ExceptionMatches(PyExc_OverflowError))
 522                     PyErr_Clear();
 523                 else
 524                     goto bad;
 525             }
 526         }
 527 {{if access == 'Get'}}
 528         return ms->sq_slice(obj, cstart, cstop);
 529 {{else}}
 530         return ms->sq_ass_slice(obj, cstart, cstop, value);
 531 {{endif}}
 532     }
 533 #endif
 534
 535     mp = Py_TYPE(obj)->tp_as_mapping;
 536 {{if access == 'Get'}}
 537     if (likely(mp && mp->mp_subscript))
 538 {{else}}
 539     if (likely(mp && mp->mp_ass_subscript))
 540 {{endif}}
 541 #endif
 542     {
 543         {{if access == 'Get'}}PyObject*{{else}}int{{endif}} result;
 544         PyObject *py_slice, *py_start, *py_stop;
 545         if (_py_slice) {
 546             py_slice = *_py_slice;
 547         } else {
 548             PyObject* owned_start = NULL;
 549             PyObject* owned_stop = NULL;
 550             if (_py_start) {
 551                 py_start = *_py_start;
 552             } else {
 553                 if (has_cstart) {
 554                     owned_start = py_start = PyInt_FromSsize_t(cstart);
 555                     if (unlikely(!py_start)) goto bad;
 556                 } else
 557                     py_start = Py_None;
 558             }
 559             if (_py_stop) {
 560                 py_stop = *_py_stop;
 561             } else {
 562                 if (has_cstop) {
 563                     owned_stop = py_stop = PyInt_FromSsize_t(cstop);
 564                     if (unlikely(!py_stop)) {
 565                         Py_XDECREF(owned_start);
 566                         goto bad;
 567                     }
 568                 } else
 569                     py_stop = Py_None;
 570             }
 571             py_slice = PySlice_New(py_start, py_stop, Py_None);
 572             Py_XDECREF(owned_start);
 573             Py_XDECREF(owned_stop);
 574             if (unlikely(!py_slice)) goto bad;
 575         }
 576 #if CYTHON_COMPILING_IN_CPYTHON
 577 {{if access == 'Get'}}
 578         result = mp->mp_subscript(obj, py_slice);
 579 #else
 580         result = PyObject_GetItem(obj, py_slice);
 581 {{else}}
 582         result = mp->mp_ass_subscript(obj, py_slice, value);
 583 #else
 584         result = value ? PyObject_SetItem(obj, py_slice, value) : PyObject_DelItem(obj, py_slice);
 585 {{endif}}
 586 #endif
 587         if (!_py_slice) {
 588             Py_DECREF(py_slice);
 589         }
 590         return result;
 591     }
 592     PyErr_Format(PyExc_TypeError,
 593 {{if access == 'Get'}}
 594         "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name);
 595 {{else}}
 596         "'%.200s' object does not support slice %.10s",
 597         Py_TYPE(obj)->tp_name, value ? "assignment" : "deletion");
 598 {{endif}}
 599
 600 bad:
 601     return {{if access == 'Get'}}NULL{{else}}-1{{endif}};
 602 }
 603
 604
 605 /////////////// SliceTupleAndList.proto ///////////////
 606
 607 #if CYTHON_COMPILING_IN_CPYTHON
 608 static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop);
 609 static CYTHON_INLINE PyObject* __Pyx_PyTuple_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop);
 610 #else
 611 #define __Pyx_PyList_GetSlice(seq, start, stop)   PySequence_GetSlice(seq, start, stop)
 612 #define __Pyx_PyTuple_GetSlice(seq, start, stop)  PySequence_GetSlice(seq, start, stop)
 613 #endif
 614
 615 /////////////// SliceTupleAndList ///////////////
 616
 617 #if CYTHON_COMPILING_IN_CPYTHON
 618 static CYTHON_INLINE void __Pyx_crop_slice(Py_ssize_t* _start, Py_ssize_t* _stop, Py_ssize_t* _length) {
 619     Py_ssize_t start = *_start, stop = *_stop, length = *_length;
 620     if (start < 0) {
 621         start += length;
 622         if (start < 0)
 623             start = 0;
 624     }
 625
 626     if (stop < 0)
 627         stop += length;
 628     else if (stop > length)
 629         stop = length;
 630
 631     *_length = stop - start;
 632     *_start = start;
 633     *_stop = stop;
 634 }
 635
 636 static CYTHON_INLINE void __Pyx_copy_object_array(PyObject** CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) {
 637     PyObject *v;
 638     Py_ssize_t i;
 639     for (i = 0; i < length; i++) {
 640         v = dest[i] = src[i];
 641         Py_INCREF(v);
 642     }
 643 }
 644
 645 {{for type in ['List', 'Tuple']}}
 646 static CYTHON_INLINE PyObject* __Pyx_Py{{type}}_GetSlice(
 647             PyObject* src, Py_ssize_t start, Py_ssize_t stop) {
 648     PyObject* dest;
 649     Py_ssize_t length = Py{{type}}_GET_SIZE(src);
 650     __Pyx_crop_slice(&start, &stop, &length);
 651     if (unlikely(length <= 0))
 652         return Py{{type}}_New(0);
 653
 654     dest = Py{{type}}_New(length);
 655     if (unlikely(!dest))
 656         return NULL;
 657     __Pyx_copy_object_array(
 658         ((Py{{type}}Object*)src)->ob_item + start,
 659         ((Py{{type}}Object*)dest)->ob_item,
 660         length);
 661     return dest;
 662 }
 663 {{endfor}}
 664 #endif
 665
 666
 667 /////////////// CalculateMetaclass.proto ///////////////
 668
 669 static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases);
 670
 671 /////////////// CalculateMetaclass ///////////////
 672
 673 static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) {
 674     Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases);
 675     for (i=0; i < nbases; i++) {
 676         PyTypeObject *tmptype;
 677         PyObject *tmp = PyTuple_GET_ITEM(bases, i);
 678         tmptype = Py_TYPE(tmp);
 679 #if PY_MAJOR_VERSION < 3
 680         if (tmptype == &PyClass_Type)
 681             continue;
 682 #endif
 683         if (!metaclass) {
 684             metaclass = tmptype;
 685             continue;
 686         }
 687         if (PyType_IsSubtype(metaclass, tmptype))
 688             continue;
 689         if (PyType_IsSubtype(tmptype, metaclass)) {
 690             metaclass = tmptype;
 691             continue;
 692         }
 693         // else:
 694         PyErr_SetString(PyExc_TypeError,
 695                         "metaclass conflict: "
 696                         "the metaclass of a derived class "
 697                         "must be a (non-strict) subclass "
 698                         "of the metaclasses of all its bases");
 699         return NULL;
 700     }
 701     if (!metaclass) {
 702 #if PY_MAJOR_VERSION < 3
 703         metaclass = &PyClass_Type;
 704 #else
 705         metaclass = &PyType_Type;
 706 #endif
 707     }
 708     // make owned reference
 709     Py_INCREF((PyObject*) metaclass);
 710     return (PyObject*) metaclass;
 711 }
 712
 713
 714 /////////////// FindInheritedMetaclass.proto ///////////////
 715
 716 static PyObject *__Pyx_FindInheritedMetaclass(PyObject *bases); /*proto*/
 717
 718 /////////////// FindInheritedMetaclass ///////////////
 719 //@requires: PyObjectGetAttrStr
 720 //@requires: CalculateMetaclass
 721
 722 static PyObject *__Pyx_FindInheritedMetaclass(PyObject *bases) {
 723     PyObject *metaclass;
 724     if (PyTuple_Check(bases) && PyTuple_GET_SIZE(bases) > 0) {
 725         PyTypeObject *metatype;
 726         PyObject *base = PyTuple_GET_ITEM(bases, 0);
 727 #if PY_MAJOR_VERSION < 3
 728         PyObject* basetype = __Pyx_PyObject_GetAttrStr(base, PYIDENT("__class__"));
 729         if (basetype) {
 730             metatype = (PyType_Check(basetype)) ? ((PyTypeObject*) basetype) : NULL;
 731         } else {
 732             PyErr_Clear();
 733             metatype = Py_TYPE(base);
 734             basetype = (PyObject*) metatype;
 735             Py_INCREF(basetype);
 736         }
 737 #else
 738         metatype = Py_TYPE(base);
 739 #endif
 740         metaclass = __Pyx_CalculateMetaclass(metatype, bases);
 741 #if PY_MAJOR_VERSION < 3
 742         Py_DECREF(basetype);
 743 #endif
 744     } else {
 745         // no bases => use default metaclass
 746 #if PY_MAJOR_VERSION < 3
 747         metaclass = (PyObject *) &PyClass_Type;
 748 #else
 749         metaclass = (PyObject *) &PyType_Type;
 750 #endif
 751         Py_INCREF(metaclass);
 752     }
 753     return metaclass;
 754 }
 755
 756 /////////////// Py3MetaclassGet.proto ///////////////
 757
 758 static PyObject *__Pyx_Py3MetaclassGet(PyObject *bases, PyObject *mkw); /*proto*/
 759
 760 /////////////// Py3MetaclassGet ///////////////
 761 //@requires: FindInheritedMetaclass
 762 //@requires: CalculateMetaclass
 763
 764 static PyObject *__Pyx_Py3MetaclassGet(PyObject *bases, PyObject *mkw) {
 765     PyObject *metaclass = PyDict_GetItem(mkw, PYIDENT("metaclass"));
 766     if (metaclass) {
 767         Py_INCREF(metaclass);
 768         if (PyDict_DelItem(mkw, PYIDENT("metaclass")) < 0) {
 769             Py_DECREF(metaclass);
 770             return NULL;
 771         }
 772         if (PyType_Check(metaclass)) {
 773             PyObject* orig = metaclass;
 774             metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases);
 775             Py_DECREF(orig);
 776         }
 777         return metaclass;
 778     }
 779     return __Pyx_FindInheritedMetaclass(bases);
 780 }
 781
 782 /////////////// CreateClass.proto ///////////////
 783
 784 static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name,
 785                                    PyObject *qualname, PyObject *modname); /*proto*/
 786
 787 /////////////// CreateClass ///////////////
 788 //@requires: FindInheritedMetaclass
 789 //@requires: CalculateMetaclass
 790
 791 static PyObject *__Pyx_CreateClass(PyObject *bases, PyObject *dict, PyObject *name,
 792                                    PyObject *qualname, PyObject *modname) {
 793     PyObject *result;
 794     PyObject *metaclass;
 795
 796     if (PyDict_SetItem(dict, PYIDENT("__module__"), modname) < 0)
 797         return NULL;
 798     if (PyDict_SetItem(dict, PYIDENT("__qualname__"), qualname) < 0)
 799         return NULL;
 800
 801     /* Python2 __metaclass__ */
 802     metaclass = PyDict_GetItem(dict, PYIDENT("__metaclass__"));
 803     if (metaclass) {
 804         Py_INCREF(metaclass);
 805         if (PyType_Check(metaclass)) {
 806             PyObject* orig = metaclass;
 807             metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases);
 808             Py_DECREF(orig);
 809         }
 810     } else {
 811         metaclass = __Pyx_FindInheritedMetaclass(bases);
 812     }
 813     if (unlikely(!metaclass))
 814         return NULL;
 815     result = PyObject_CallFunctionObjArgs(metaclass, name, bases, dict, NULL);
 816     Py_DECREF(metaclass);
 817     return result;
 818 }
 819
 820 /////////////// Py3ClassCreate.proto ///////////////
 821
 822 static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname,
 823                                            PyObject *mkw, PyObject *modname, PyObject *doc); /*proto*/
 824 static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict,
 825                                       PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); /*proto*/
 826
 827 /////////////// Py3ClassCreate ///////////////
 828 //@requires: PyObjectGetAttrStr
 829 //@requires: CalculateMetaclass
 830
 831 static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name,
 832                                            PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) {
 833     PyObject *ns;
 834     if (metaclass) {
 835         PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, PYIDENT("__prepare__"));
 836         if (prep) {
 837             PyObject *pargs = PyTuple_Pack(2, name, bases);
 838             if (unlikely(!pargs)) {
 839                 Py_DECREF(prep);
 840                 return NULL;
 841             }
 842             ns = PyObject_Call(prep, pargs, mkw);
 843             Py_DECREF(prep);
 844             Py_DECREF(pargs);
 845         } else {
 846             if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError)))
 847                 return NULL;
 848             PyErr_Clear();
 849             ns = PyDict_New();
 850         }
 851     } else {
 852         ns = PyDict_New();
 853     }
 854
 855     if (unlikely(!ns))
 856         return NULL;
 857
 858     /* Required here to emulate assignment order */
 859     if (unlikely(PyObject_SetItem(ns, PYIDENT("__module__"), modname) < 0)) goto bad;
 860     if (unlikely(PyObject_SetItem(ns, PYIDENT("__qualname__"), qualname) < 0)) goto bad;
 861     if (unlikely(doc && PyObject_SetItem(ns, PYIDENT("__doc__"), doc) < 0)) goto bad;
 862     return ns;
 863 bad:
 864     Py_DECREF(ns);
 865     return NULL;
 866 }
 867
 868 static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases,
 869                                       PyObject *dict, PyObject *mkw,
 870                                       int calculate_metaclass, int allow_py2_metaclass) {
 871     PyObject *result, *margs;
 872     PyObject *owned_metaclass = NULL;
 873     if (allow_py2_metaclass) {
 874         /* honour Python2 __metaclass__ for backward compatibility */
 875         owned_metaclass = PyObject_GetItem(dict, PYIDENT("__metaclass__"));
 876         if (owned_metaclass) {
 877             metaclass = owned_metaclass;
 878         } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) {
 879             PyErr_Clear();
 880         } else {
 881             return NULL;
 882         }
 883     }
 884     if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) {
 885         metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases);
 886         Py_XDECREF(owned_metaclass);
 887         if (unlikely(!metaclass))
 888             return NULL;
 889         owned_metaclass = metaclass;
 890     }
 891     margs = PyTuple_Pack(3, name, bases, dict);
 892     if (unlikely(!margs)) {
 893         result = NULL;
 894     } else {
 895         result = PyObject_Call(metaclass, margs, mkw);
 896         Py_DECREF(margs);
 897     }
 898     Py_XDECREF(owned_metaclass);
 899     return result;
 900 }
 901
 902 /////////////// ExtTypeTest.proto ///////////////
 903
 904 static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/
 905
 906 /////////////// ExtTypeTest ///////////////
 907
 908 static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) {
 909     if (unlikely(!type)) {
 910         PyErr_SetString(PyExc_SystemError, "Missing type object");
 911         return 0;
 912     }
 913     if (likely(PyObject_TypeCheck(obj, type)))
 914         return 1;
 915     PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s",
 916                  Py_TYPE(obj)->tp_name, type->tp_name);
 917     return 0;
 918 }
 919
 920 /////////////// CallableCheck.proto ///////////////
 921
 922 #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3
 923 #define __Pyx_PyCallable_Check(obj)   ((obj)->ob_type->tp_call != NULL)
 924 #else
 925 #define __Pyx_PyCallable_Check(obj)   PyCallable_Check(obj)
 926 #endif
 927
 928 /////////////// PyDictContains.proto ///////////////
 929
 930 static CYTHON_INLINE int __Pyx_PyDict_Contains(PyObject* item, PyObject* dict, int eq) {
 931     int result = PyDict_Contains(dict, item);
 932     return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
 933 }
 934
 935 /////////////// PySequenceContains.proto ///////////////
 936
 937 static CYTHON_INLINE int __Pyx_PySequence_Contains(PyObject* item, PyObject* seq, int eq) {
 938     int result = PySequence_Contains(seq, item);
 939     return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
 940 }
 941
 942 /////////////// PyBoolOrNullFromLong.proto ///////////////
 943
 944 static CYTHON_INLINE PyObject* __Pyx_PyBoolOrNull_FromLong(long b) {
 945     return unlikely(b < 0) ? NULL : __Pyx_PyBool_FromLong(b);
 946 }
 947
 948 /////////////// GetBuiltinName.proto ///////////////
 949
 950 static PyObject *__Pyx_GetBuiltinName(PyObject *name); /*proto*/
 951
 952 /////////////// GetBuiltinName ///////////////
 953 //@requires: PyObjectGetAttrStr
 954 //@substitute: naming
 955
 956 static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
 957     PyObject* result = __Pyx_PyObject_GetAttrStr($builtins_cname, name);
 958     if (unlikely(!result)) {
 959         PyErr_Format(PyExc_NameError,
 960 #if PY_MAJOR_VERSION >= 3
 961             "name '%U' is not defined", name);
 962 #else
 963             "name '%.200s' is not defined", PyString_AS_STRING(name));
 964 #endif
 965     }
 966     return result;
 967 }
 968
 969 /////////////// GetNameInClass.proto ///////////////
 970
 971 static PyObject *__Pyx_GetNameInClass(PyObject *nmspace, PyObject *name); /*proto*/
 972
 973 /////////////// GetNameInClass ///////////////
 974 //@requires: PyObjectGetAttrStr
 975 //@requires: GetModuleGlobalName
 976
 977 static PyObject *__Pyx_GetNameInClass(PyObject *nmspace, PyObject *name) {
 978     PyObject *result;
 979     result = __Pyx_PyObject_GetAttrStr(nmspace, name);
 980     if (!result)
 981         result = __Pyx_GetModuleGlobalName(name);
 982     return result;
 983 }
 984
 985 /////////////// GetModuleGlobalName.proto ///////////////
 986
 987 static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); /*proto*/
 988
 989 /////////////// GetModuleGlobalName ///////////////
 990 //@requires: GetBuiltinName
 991 //@substitute: naming
 992
 993 static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) {
 994     PyObject *result;
 995 #if CYTHON_COMPILING_IN_CPYTHON
 996     result = PyDict_GetItem($moddict_cname, name);
 997     if (result) {
 998         Py_INCREF(result);
 999     } else {
1000 #else
1001     result = PyObject_GetItem($moddict_cname, name);
1002     if (!result) {
1003         PyErr_Clear();
1004 #endif
1005         result = __Pyx_GetBuiltinName(name);
1006     }
1007     return result;
1008 }
1009
1010 //////////////////// GetAttr.proto ////////////////////
1011
1012 static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /*proto*/
1013
1014 //////////////////// GetAttr ////////////////////
1015 //@requires: PyObjectGetAttrStr
1016
1017 static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) {
1018 #if CYTHON_COMPILING_IN_CPYTHON
1019 #if PY_MAJOR_VERSION >= 3
1020     if (likely(PyUnicode_Check(n)))
1021 #else
1022     if (likely(PyString_Check(n)))
1023 #endif
1024         return __Pyx_PyObject_GetAttrStr(o, n);
1025 #endif
1026     return PyObject_GetAttr(o, n);
1027 }
1028
1029 /////////////// PyObjectLookupSpecial.proto ///////////////
1030 //@requires: PyObjectGetAttrStr
1031
1032 #if CYTHON_COMPILING_IN_CPYTHON && (PY_VERSION_HEX >= 0x03020000 || PY_MAJOR_VERSION < 3 && PY_VERSION_HEX >= 0x02070000)
1033 // looks like calling _PyType_Lookup() isn't safe in Py<=2.6/3.1
1034 static CYTHON_INLINE PyObject* __Pyx_PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name) {
1035     PyObject *res;
1036     PyTypeObject *tp = Py_TYPE(obj);
1037 #if PY_MAJOR_VERSION < 3
1038     if (unlikely(PyInstance_Check(obj)))
1039         return __Pyx_PyObject_GetAttrStr(obj, attr_name);
1040 #endif
1041     // adapted from CPython's special_lookup() in ceval.c
1042     res = _PyType_Lookup(tp, attr_name);
1043     if (likely(res)) {
1044         descrgetfunc f = Py_TYPE(res)->tp_descr_get;
1045         if (!f) {
1046             Py_INCREF(res);
1047         } else {
1048             res = f(res, obj, (PyObject *)tp);
1049         }
1050     } else {
1051         PyErr_SetObject(PyExc_AttributeError, attr_name);
1052     }
1053     return res;
1054 }
1055 #else
1056 #define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n)
1057 #endif
1058
1059 /////////////// PyObjectGetAttrStr.proto ///////////////
1060
1061 #if CYTHON_COMPILING_IN_CPYTHON
1062 static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
1063     PyTypeObject* tp = Py_TYPE(obj);
1064     if (likely(tp->tp_getattro))
1065         return tp->tp_getattro(obj, attr_name);
1066 #if PY_MAJOR_VERSION < 3
1067     if (likely(tp->tp_getattr))
1068         return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
1069 #endif
1070     return PyObject_GetAttr(obj, attr_name);
1071 }
1072 #else
1073 #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
1074 #endif
1075
1076 /////////////// PyObjectSetAttrStr.proto ///////////////
1077
1078 #if CYTHON_COMPILING_IN_CPYTHON
1079 #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL)
1080 static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) {
1081     PyTypeObject* tp = Py_TYPE(obj);
1082     if (likely(tp->tp_setattro))
1083         return tp->tp_setattro(obj, attr_name, value);
1084 #if PY_MAJOR_VERSION < 3
1085     if (likely(tp->tp_setattr))
1086         return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value);
1087 #endif
1088     return PyObject_SetAttr(obj, attr_name, value);
1089 }
1090 #else
1091 #define __Pyx_PyObject_DelAttrStr(o,n)   PyObject_DelAttr(o,n)
1092 #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v)
1093 #endif
1094
1095 /////////////// PyObjectCallMethod.proto ///////////////
1096 //@requires: PyObjectGetAttrStr
1097 //@requires: PyObjectCall
1098 //@substitute: naming
1099
1100 static PyObject* __Pyx_PyObject_CallMethodTuple(PyObject* obj, PyObject* method_name, PyObject* args) {
1101     PyObject *method, *result = NULL;
1102     if (unlikely(!args)) return NULL;
1103     method = __Pyx_PyObject_GetAttrStr(obj, method_name);
1104     if (unlikely(!method)) goto bad;
1105     result = __Pyx_PyObject_Call(method, args, NULL);
1106     Py_DECREF(method);
1107 bad:
1108     Py_DECREF(args);
1109     return result;
1110 }
1111
1112 #define __Pyx_PyObject_CallMethod3(obj, name, arg1, arg2, arg3) \
1113     __Pyx_PyObject_CallMethodTuple(obj, name, PyTuple_Pack(3, arg1, arg2, arg3))
1114 #define __Pyx_PyObject_CallMethod2(obj, name, arg1, arg2) \
1115     __Pyx_PyObject_CallMethodTuple(obj, name, PyTuple_Pack(2, arg1, arg2))
1116 #define __Pyx_PyObject_CallMethod1(obj, name, arg1) \
1117     __Pyx_PyObject_CallMethodTuple(obj, name, PyTuple_Pack(1, arg1))
1118 #define __Pyx_PyObject_CallMethod0(obj, name) \
1119     __Pyx_PyObject_CallMethodTuple(obj, name, (Py_INCREF($empty_tuple), $empty_tuple))
1120
1121
1122 /////////////// tp_new.proto ///////////////
1123
1124 #define __Pyx_tp_new(type_obj, args) __Pyx_tp_new_kwargs(type_obj, args, NULL)
1125 static CYTHON_INLINE PyObject* __Pyx_tp_new_kwargs(PyObject* type_obj, PyObject* args, PyObject* kwargs) {
1126     return (PyObject*) (((PyTypeObject*)type_obj)->tp_new((PyTypeObject*)type_obj, args, kwargs));
1127 }
1128
1129
1130 /////////////// PyObjectCall.proto ///////////////
1131
1132 #if CYTHON_COMPILING_IN_CPYTHON
1133 static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); /*proto*/
1134 #else
1135 #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
1136 #endif
1137
1138 /////////////// PyObjectCall ///////////////
1139
1140 #if CYTHON_COMPILING_IN_CPYTHON
1141 static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
1142     PyObject *result;
1143     ternaryfunc call = func->ob_type->tp_call;
1144
1145     if (unlikely(!call))
1146         return PyObject_Call(func, arg, kw);
1147 #if PY_VERSION_HEX >= 0x02060000
1148     if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
1149         return NULL;
1150 #endif
1151     result = (*call)(func, arg, kw);
1152 #if PY_VERSION_HEX >= 0x02060000
1153     Py_LeaveRecursiveCall();
1154 #endif
1155     if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
1156         PyErr_SetString(
1157             PyExc_SystemError,
1158             "NULL result without error in PyObject_Call");
1159     }
1160     return result;
1161 }
1162 #endif