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 12static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); 13 14/////////////// RaiseNoneIterError /////////////// 15 16static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { 17 PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); 18} 19 20/////////////// RaiseTooManyValuesToUnpack.proto /////////////// 21 22static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); 23 24/////////////// RaiseTooManyValuesToUnpack /////////////// 25 26static 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 33static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); 34 35/////////////// RaiseNeedMoreValuesToUnpack /////////////// 36 37static 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 45static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /*proto*/ 46 47/////////////// UnpackTupleError /////////////// 48//@requires: RaiseNoneIterError 49//@requires: RaiseNeedMoreValuesToUnpack 50//@requires: RaiseTooManyValuesToUnpack 51 52static 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 64static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /*proto*/ 65 66/////////////// UnpackItemEndCheck /////////////// 67//@requires: RaiseTooManyValuesToUnpack 68//@requires: IterFinish 69 70static 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 83static 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 91static 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; 126unpacking_failed: 127 if (!has_known_size && __Pyx_IterFinish() == 0) 128 __Pyx_RaiseNeedMoreValuesError(index); 129bad: 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) 140static CYTHON_INLINE PyObject *__Pyx_PyIter_Next2(PyObject *, PyObject *); /*proto*/ 141 142/////////////// IterNext /////////////// 143 144// originally copied from Py3's builtin_next() 145static 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 184static 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 192static 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 229static 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 262static CYTHON_INLINE PyObject *__Pyx_GetItemInt_{{type}}_Fast(PyObject *o, Py_ssize_t i, 263 int wraparound, int boundscheck); 264{{endfor}} 265 266static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); 267static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, 268 int is_list, int wraparound, int boundscheck); 269 270/////////////// GetItemInt /////////////// 271 272static 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']}} 281static 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 297static 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 350static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); 351static 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 356static 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 364static 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 416static CYTHON_INLINE int __Pyx_DelItem_Generic(PyObject *o, PyObject *j); 417static CYTHON_INLINE int __Pyx_DelItemInt_Fast(PyObject *o, Py_ssize_t i, 418 CYTHON_UNUSED int is_list, int wraparound); 419 420/////////////// DelItemInt /////////////// 421 422static 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 430static 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'}} 463static 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 472static 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'}} 481static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( 482 PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, 483{{else}} 484static 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 600bad: 601 return {{if access == 'Get'}}NULL{{else}}-1{{endif}}; 602} 603 604 605/////////////// SliceTupleAndList.proto /////////////// 606 607#if CYTHON_COMPILING_IN_CPYTHON 608static CYTHON_INLINE PyObject* __Pyx_PyList_GetSlice(PyObject* src, Py_ssize_t start, Py_ssize_t stop); 609static 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 618static 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 636static 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']}} 646static 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 669static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); 670 671/////////////// CalculateMetaclass /////////////// 672 673static 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 716static PyObject *__Pyx_FindInheritedMetaclass(PyObject *bases); /*proto*/ 717 718/////////////// FindInheritedMetaclass /////////////// 719//@requires: PyObjectGetAttrStr 720//@requires: CalculateMetaclass 721 722static 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 758static PyObject *__Pyx_Py3MetaclassGet(PyObject *bases, PyObject *mkw); /*proto*/ 759 760/////////////// Py3MetaclassGet /////////////// 761//@requires: FindInheritedMetaclass 762//@requires: CalculateMetaclass 763 764static 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 784static 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 791static 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 822static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, 823 PyObject *mkw, PyObject *modname, PyObject *doc); /*proto*/ 824static 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 831static 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; 863bad: 864 Py_DECREF(ns); 865 return NULL; 866} 867 868static 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 904static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /*proto*/ 905 906/////////////// ExtTypeTest /////////////// 907 908static 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 930static 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 937static 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 944static CYTHON_INLINE PyObject* __Pyx_PyBoolOrNull_FromLong(long b) { 945 return unlikely(b < 0) ? NULL : __Pyx_PyBool_FromLong(b); 946} 947 948/////////////// GetBuiltinName.proto /////////////// 949 950static PyObject *__Pyx_GetBuiltinName(PyObject *name); /*proto*/ 951 952/////////////// GetBuiltinName /////////////// 953//@requires: PyObjectGetAttrStr 954//@substitute: naming 955 956static 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 971static PyObject *__Pyx_GetNameInClass(PyObject *nmspace, PyObject *name); /*proto*/ 972 973/////////////// GetNameInClass /////////////// 974//@requires: PyObjectGetAttrStr 975//@requires: GetModuleGlobalName 976 977static 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 987static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); /*proto*/ 988 989/////////////// GetModuleGlobalName /////////////// 990//@requires: GetBuiltinName 991//@substitute: naming 992 993static 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 1012static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /*proto*/ 1013 1014//////////////////// GetAttr //////////////////// 1015//@requires: PyObjectGetAttrStr 1016 1017static 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 1034static 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 1062static 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) 1080static 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 1100static 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); 1107bad: 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) 1125static 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 1133static 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 1141static 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 1163