1/////////////// TypeConversions.proto /////////////// 2 3/* Type Conversion Predeclarations */ 4 5#define __Pyx_fits_Py_ssize_t(v, type, is_signed) ( \ 6 (sizeof(type) < sizeof(Py_ssize_t)) || \ 7 (sizeof(type) > sizeof(Py_ssize_t) && \ 8 likely(v < (type)PY_SSIZE_T_MAX || \ 9 v == (type)PY_SSIZE_T_MAX) && \ 10 (!is_signed || likely(v > (type)PY_SSIZE_T_MIN || \ 11 v == (type)PY_SSIZE_T_MIN))) || \ 12 (sizeof(type) == sizeof(Py_ssize_t) && \ 13 (is_signed || likely(v < (type)PY_SSIZE_T_MAX || \ 14 v == (type)PY_SSIZE_T_MAX))) ) 15 16static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); 17static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); 18 19#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) 20#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) 21#define __Pyx_PyBytes_FromString PyBytes_FromString 22#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize 23static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); 24 25#if PY_MAJOR_VERSION < 3 26 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString 27 #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize 28#else 29 #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString 30 #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize 31#endif 32 33#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) 34#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) 35#define __Pyx_PyObject_FromUString(s) __Pyx_PyObject_FromString((const char*)s) 36#define __Pyx_PyBytes_FromUString(s) __Pyx_PyBytes_FromString((const char*)s) 37#define __Pyx_PyByteArray_FromUString(s) __Pyx_PyByteArray_FromString((const char*)s) 38#define __Pyx_PyStr_FromUString(s) __Pyx_PyStr_FromString((const char*)s) 39#define __Pyx_PyUnicode_FromUString(s) __Pyx_PyUnicode_FromString((const char*)s) 40 41#if PY_MAJOR_VERSION < 3 42static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) 43{ 44 const Py_UNICODE *u_end = u; 45 while (*u_end++) ; 46 return (size_t)(u_end - u - 1); 47} 48#else 49#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen 50#endif 51 52#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) 53#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode 54#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode 55 56#define __Pyx_Owned_Py_None(b) (Py_INCREF(Py_None), Py_None) 57#define __Pyx_PyBool_FromLong(b) ((b) ? (Py_INCREF(Py_True), Py_True) : (Py_INCREF(Py_False), Py_False)) 58static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); 59static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); 60 61static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); 62static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); 63 64#if CYTHON_COMPILING_IN_CPYTHON 65#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) 66#else 67#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) 68#endif 69#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) 70 71#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 72static int __Pyx_sys_getdefaultencoding_not_ascii; 73static int __Pyx_init_sys_getdefaultencoding_params(void) { 74 PyObject* sys; 75 PyObject* default_encoding = NULL; 76 PyObject* ascii_chars_u = NULL; 77 PyObject* ascii_chars_b = NULL; 78 const char* default_encoding_c; 79 sys = PyImport_ImportModule("sys"); 80 if (!sys) goto bad; 81 default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); 82 Py_DECREF(sys); 83 if (!default_encoding) goto bad; 84 default_encoding_c = PyBytes_AsString(default_encoding); 85 if (!default_encoding_c) goto bad; 86 if (strcmp(default_encoding_c, "ascii") == 0) { 87 __Pyx_sys_getdefaultencoding_not_ascii = 0; 88 } else { 89 char ascii_chars[128]; 90 int c; 91 for (c = 0; c < 128; c++) { 92 ascii_chars[c] = c; 93 } 94 __Pyx_sys_getdefaultencoding_not_ascii = 1; 95 ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); 96 if (!ascii_chars_u) goto bad; 97 ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); 98 if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { 99 PyErr_Format( 100 PyExc_ValueError, 101 "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", 102 default_encoding_c); 103 goto bad; 104 } 105 Py_DECREF(ascii_chars_u); 106 Py_DECREF(ascii_chars_b); 107 } 108 Py_DECREF(default_encoding); 109 return 0; 110bad: 111 Py_XDECREF(default_encoding); 112 Py_XDECREF(ascii_chars_u); 113 Py_XDECREF(ascii_chars_b); 114 return -1; 115} 116#endif 117 118#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 119#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) 120#else 121#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) 122 123// __PYX_DEFAULT_STRING_ENCODING is either a user provided string constant 124// or we need to look it up here 125#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 126static char* __PYX_DEFAULT_STRING_ENCODING; 127 128static int __Pyx_init_sys_getdefaultencoding_params(void) { 129 PyObject* sys; 130 PyObject* default_encoding = NULL; 131 char* default_encoding_c; 132 133 sys = PyImport_ImportModule("sys"); 134 if (!sys) goto bad; 135 default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); 136 Py_DECREF(sys); 137 if (!default_encoding) goto bad; 138 default_encoding_c = PyBytes_AsString(default_encoding); 139 if (!default_encoding_c) goto bad; 140 __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); 141 if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; 142 strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); 143 Py_DECREF(default_encoding); 144 return 0; 145bad: 146 Py_XDECREF(default_encoding); 147 return -1; 148} 149#endif 150#endif 151 152/////////////// TypeConversions /////////////// 153 154/* Type Conversion Functions */ 155 156static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { 157 return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); 158} 159 160static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { 161 Py_ssize_t ignore; 162 return __Pyx_PyObject_AsStringAndSize(o, &ignore); 163} 164 165static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { 166#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 167 if ( 168#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 169 __Pyx_sys_getdefaultencoding_not_ascii && 170#endif 171 PyUnicode_Check(o)) { 172#if PY_VERSION_HEX < 0x03030000 173 char* defenc_c; 174 // borrowed, cached reference 175 PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); 176 if (!defenc) return NULL; 177 defenc_c = PyBytes_AS_STRING(defenc); 178#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 179 { 180 char* end = defenc_c + PyBytes_GET_SIZE(defenc); 181 char* c; 182 for (c = defenc_c; c < end; c++) { 183 if ((unsigned char) (*c) >= 128) { 184 // raise the error 185 PyUnicode_AsASCIIString(o); 186 return NULL; 187 } 188 } 189 } 190#endif /*__PYX_DEFAULT_STRING_ENCODING_IS_ASCII*/ 191 *length = PyBytes_GET_SIZE(defenc); 192 return defenc_c; 193#else /* PY_VERSION_HEX < 0x03030000 */ 194 if (PyUnicode_READY(o) == -1) return NULL; 195#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 196 if (PyUnicode_IS_ASCII(o)) { 197 // cached for the lifetime of the object 198 *length = PyUnicode_GET_LENGTH(o); 199 return PyUnicode_AsUTF8(o); 200 } else { 201 // raise the error 202 PyUnicode_AsASCIIString(o); 203 return NULL; 204 } 205#else /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII */ 206 return PyUnicode_AsUTF8AndSize(o, length); 207#endif /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII */ 208#endif /* PY_VERSION_HEX < 0x03030000 */ 209 } else 210#endif /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT */ 211 212#if !CYTHON_COMPILING_IN_PYPY 213#if PY_VERSION_HEX >= 0x02060000 214 if (PyByteArray_Check(o)) { 215 *length = PyByteArray_GET_SIZE(o); 216 return PyByteArray_AS_STRING(o); 217 } else 218#endif 219#endif 220 { 221 char* result; 222 int r = PyBytes_AsStringAndSize(o, &result, length); 223 if (unlikely(r < 0)) { 224 return NULL; 225 } else { 226 return result; 227 } 228 } 229} 230 231/* Note: __Pyx_PyObject_IsTrue is written to minimize branching. */ 232static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { 233 int is_true = x == Py_True; 234 if (is_true | (x == Py_False) | (x == Py_None)) return is_true; 235 else return PyObject_IsTrue(x); 236} 237 238static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { 239 PyNumberMethods *m; 240 const char *name = NULL; 241 PyObject *res = NULL; 242#if PY_MAJOR_VERSION < 3 243 if (PyInt_Check(x) || PyLong_Check(x)) 244#else 245 if (PyLong_Check(x)) 246#endif 247 return Py_INCREF(x), x; 248 m = Py_TYPE(x)->tp_as_number; 249#if PY_MAJOR_VERSION < 3 250 if (m && m->nb_int) { 251 name = "int"; 252 res = PyNumber_Int(x); 253 } 254 else if (m && m->nb_long) { 255 name = "long"; 256 res = PyNumber_Long(x); 257 } 258#else 259 if (m && m->nb_int) { 260 name = "int"; 261 res = PyNumber_Long(x); 262 } 263#endif 264 if (res) { 265#if PY_MAJOR_VERSION < 3 266 if (!PyInt_Check(res) && !PyLong_Check(res)) { 267#else 268 if (!PyLong_Check(res)) { 269#endif 270 PyErr_Format(PyExc_TypeError, 271 "__%.4s__ returned non-%.4s (type %.200s)", 272 name, name, Py_TYPE(res)->tp_name); 273 Py_DECREF(res); 274 return NULL; 275 } 276 } 277 else if (!PyErr_Occurred()) { 278 PyErr_SetString(PyExc_TypeError, 279 "an integer is required"); 280 } 281 return res; 282} 283 284#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 285 #if CYTHON_USE_PYLONG_INTERNALS 286 #include "longintrepr.h" 287 #endif 288#endif 289static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { 290 Py_ssize_t ival; 291 PyObject *x; 292#if PY_MAJOR_VERSION < 3 293 if (likely(PyInt_CheckExact(b))) 294 return PyInt_AS_LONG(b); 295#endif 296 if (likely(PyLong_CheckExact(b))) { 297 #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 298 #if CYTHON_USE_PYLONG_INTERNALS 299 switch (Py_SIZE(b)) { 300 case -1: return -(sdigit)((PyLongObject*)b)->ob_digit[0]; 301 case 0: return 0; 302 case 1: return ((PyLongObject*)b)->ob_digit[0]; 303 } 304 #endif 305 #endif 306 #if PY_VERSION_HEX < 0x02060000 307 return PyInt_AsSsize_t(b); 308 #else 309 return PyLong_AsSsize_t(b); 310 #endif 311 } 312 x = PyNumber_Index(b); 313 if (!x) return -1; 314 ival = PyInt_AsSsize_t(x); 315 Py_DECREF(x); 316 return ival; 317} 318 319static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { 320#if PY_VERSION_HEX < 0x02050000 321 if (ival <= LONG_MAX) 322 return PyInt_FromLong((long)ival); 323 else { 324 unsigned char *bytes = (unsigned char *) &ival; 325 int one = 1; int little = (int)*(unsigned char*)&one; 326 return _PyLong_FromByteArray(bytes, sizeof(size_t), little, 0); 327 } 328#else 329 return PyInt_FromSize_t(ival); 330#endif 331} 332 333 334/////////////// FromPyStructUtility.proto /////////////// 335{{struct_type_decl}}; 336static {{struct_type_decl}} {{funcname}}(PyObject *); 337 338/////////////// FromPyStructUtility /////////////// 339static {{struct_type_decl}} {{funcname}}(PyObject * o) { 340 {{struct_type_decl}} result; 341 PyObject *value = NULL; 342 343 if (!PyMapping_Check(o)) { 344 PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "a mapping", Py_TYPE(o)->tp_name); 345 goto bad; 346 } 347 348 {{for member in var_entries:}} 349 {{py:attr = "result." + member.cname}} 350 351 value = PyObject_GetItem(o, PYIDENT("{{member.name}}")); 352 if (!value) { 353 PyErr_Format(PyExc_ValueError, \ 354 "No value specified for struct attribute '%.{{max(200, len(member.name))}}s'", "{{member.name}}"); 355 goto bad; 356 } 357 {{attr}} = {{member.type.from_py_function}}(value); 358 if ({{member.type.error_condition(attr)}}) 359 goto bad; 360 361 Py_DECREF(value); 362 {{endfor}} 363 364 return result; 365bad: 366 Py_XDECREF(value); 367 return result; 368} 369 370/////////////// ObjectAsUCS4.proto /////////////// 371 372static CYTHON_INLINE Py_UCS4 __Pyx_PyObject_AsPy_UCS4(PyObject*); 373 374/////////////// ObjectAsUCS4 /////////////// 375 376static CYTHON_INLINE Py_UCS4 __Pyx_PyObject_AsPy_UCS4(PyObject* x) { 377 long ival; 378 if (PyUnicode_Check(x)) { 379 Py_ssize_t length; 380 #if CYTHON_PEP393_ENABLED 381 length = PyUnicode_GET_LENGTH(x); 382 if (likely(length == 1)) { 383 return PyUnicode_READ_CHAR(x, 0); 384 } 385 #else 386 length = PyUnicode_GET_SIZE(x); 387 if (likely(length == 1)) { 388 return PyUnicode_AS_UNICODE(x)[0]; 389 } 390 #if Py_UNICODE_SIZE == 2 391 else if (PyUnicode_GET_SIZE(x) == 2) { 392 Py_UCS4 high_val = PyUnicode_AS_UNICODE(x)[0]; 393 if (high_val >= 0xD800 && high_val <= 0xDBFF) { 394 Py_UCS4 low_val = PyUnicode_AS_UNICODE(x)[1]; 395 if (low_val >= 0xDC00 && low_val <= 0xDFFF) { 396 return 0x10000 + (((high_val & ((1<<10)-1)) << 10) | (low_val & ((1<<10)-1))); 397 } 398 } 399 } 400 #endif 401 #endif 402 PyErr_Format(PyExc_ValueError, 403 "only single character unicode strings can be converted to Py_UCS4, " 404 "got length %" CYTHON_FORMAT_SSIZE_T "d", length); 405 return (Py_UCS4)-1; 406 } 407 ival = __Pyx_PyInt_As_long(x); 408 if (unlikely(ival < 0)) { 409 if (!PyErr_Occurred()) 410 PyErr_SetString(PyExc_OverflowError, 411 "cannot convert negative value to Py_UCS4"); 412 return (Py_UCS4)-1; 413 } else if (unlikely(ival > 1114111)) { 414 PyErr_SetString(PyExc_OverflowError, 415 "value too large to convert to Py_UCS4"); 416 return (Py_UCS4)-1; 417 } 418 return (Py_UCS4)ival; 419} 420 421/////////////// ObjectAsPyUnicode.proto /////////////// 422 423static CYTHON_INLINE Py_UNICODE __Pyx_PyObject_AsPy_UNICODE(PyObject*); 424 425/////////////// ObjectAsPyUnicode /////////////// 426 427static CYTHON_INLINE Py_UNICODE __Pyx_PyObject_AsPy_UNICODE(PyObject* x) { 428 long ival; 429 #if CYTHON_PEP393_ENABLED 430 #if Py_UNICODE_SIZE > 2 431 const long maxval = 1114111; 432 #else 433 const long maxval = 65535; 434 #endif 435 #else 436 static long maxval = 0; 437 #endif 438 if (PyUnicode_Check(x)) { 439 if (unlikely(__Pyx_PyUnicode_GET_LENGTH(x) != 1)) { 440 PyErr_Format(PyExc_ValueError, 441 "only single character unicode strings can be converted to Py_UNICODE, " 442 "got length %" CYTHON_FORMAT_SSIZE_T "d", __Pyx_PyUnicode_GET_LENGTH(x)); 443 return (Py_UNICODE)-1; 444 } 445 #if CYTHON_PEP393_ENABLED 446 ival = PyUnicode_READ_CHAR(x, 0); 447 #else 448 return PyUnicode_AS_UNICODE(x)[0]; 449 #endif 450 } else { 451 #if !CYTHON_PEP393_ENABLED 452 if (unlikely(!maxval)) 453 maxval = (long)PyUnicode_GetMax(); 454 #endif 455 ival = __Pyx_PyInt_As_long(x); 456 } 457 if (unlikely(ival < 0)) { 458 if (!PyErr_Occurred()) 459 PyErr_SetString(PyExc_OverflowError, 460 "cannot convert negative value to Py_UNICODE"); 461 return (Py_UNICODE)-1; 462 } else if (unlikely(ival > maxval)) { 463 PyErr_SetString(PyExc_OverflowError, 464 "value too large to convert to Py_UNICODE"); 465 return (Py_UNICODE)-1; 466 } 467 return (Py_UNICODE)ival; 468} 469 470 471/////////////// CIntToPy.proto /////////////// 472 473static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value); 474 475/////////////// CIntToPy /////////////// 476 477static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value) { 478 const {{TYPE}} neg_one = ({{TYPE}}) -1, const_zero = 0; 479 const int is_unsigned = neg_one > const_zero; 480 if (is_unsigned) { 481 if (sizeof({{TYPE}}) < sizeof(long)) { 482 return PyInt_FromLong((long) value); 483 } else if (sizeof({{TYPE}}) <= sizeof(unsigned long)) { 484 return PyLong_FromUnsignedLong((unsigned long) value); 485 } else if (sizeof({{TYPE}}) <= sizeof(unsigned long long)) { 486 return PyLong_FromUnsignedLongLong((unsigned long long) value); 487 } 488 } else { 489 if (sizeof({{TYPE}}) <= sizeof(long)) { 490 return PyInt_FromLong((long) value); 491 } else if (sizeof({{TYPE}}) <= sizeof(long long)) { 492 return PyLong_FromLongLong((long long) value); 493 } 494 } 495 { 496 int one = 1; int little = (int)*(unsigned char *)&one; 497 unsigned char *bytes = (unsigned char *)&value; 498 return _PyLong_FromByteArray(bytes, sizeof({{TYPE}}), 499 little, !is_unsigned); 500 } 501} 502 503 504/////////////// CIntFromPyVerify /////////////// 505 506#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func) \ 507 { \ 508 func_type value = func(x); \ 509 if (sizeof(target_type) < sizeof(func_type)) { \ 510 if (unlikely(value != (func_type) (target_type) value)) { \ 511 func_type zero = 0; \ 512 PyErr_SetString(PyExc_OverflowError, \ 513 (is_unsigned && unlikely(value < zero)) ? \ 514 "can't convert negative value to " #target_type : \ 515 "value too large to convert to " #target_type); \ 516 return (target_type) -1; \ 517 } \ 518 } \ 519 return (target_type) value; \ 520 } 521 522 523/////////////// CIntFromPy.proto /////////////// 524 525static CYTHON_INLINE {{TYPE}} {{FROM_PY_FUNCTION}}(PyObject *); 526 527/////////////// CIntFromPy /////////////// 528//@requires: CIntFromPyVerify 529 530#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 531 #if CYTHON_USE_PYLONG_INTERNALS 532 #include "longintrepr.h" 533 #endif 534#endif 535static CYTHON_INLINE {{TYPE}} {{FROM_PY_FUNCTION}}(PyObject *x) { 536 const {{TYPE}} neg_one = ({{TYPE}}) -1, const_zero = 0; 537 const int is_unsigned = neg_one > const_zero; 538#if PY_MAJOR_VERSION < 3 539 if (likely(PyInt_Check(x))) { 540 if (sizeof({{TYPE}}) < sizeof(long)) { 541 __PYX_VERIFY_RETURN_INT({{TYPE}}, long, PyInt_AS_LONG) 542 } else { 543 long val = PyInt_AS_LONG(x); 544 if (is_unsigned && unlikely(val < 0)) { 545 PyErr_SetString(PyExc_OverflowError, 546 "can't convert negative value to {{TYPE}}"); 547 return ({{TYPE}}) -1; 548 } 549 return ({{TYPE}}) val; 550 } 551 } else 552#endif 553 if (likely(PyLong_Check(x))) { 554 if (is_unsigned) { 555#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 556 #if CYTHON_USE_PYLONG_INTERNALS 557 if (sizeof(digit) <= sizeof({{TYPE}})) { 558 switch (Py_SIZE(x)) { 559 case 0: return 0; 560 case 1: return ({{TYPE}}) ((PyLongObject*)x)->ob_digit[0]; 561 } 562 } 563 #endif 564#endif 565 if (unlikely(Py_SIZE(x) < 0)) { 566 PyErr_SetString(PyExc_OverflowError, 567 "can't convert negative value to {{TYPE}}"); 568 return ({{TYPE}}) -1; 569 } 570 if (sizeof({{TYPE}}) <= sizeof(unsigned long)) { 571 __PYX_VERIFY_RETURN_INT({{TYPE}}, unsigned long, PyLong_AsUnsignedLong) 572 } else if (sizeof({{TYPE}}) <= sizeof(unsigned long long)) { 573 __PYX_VERIFY_RETURN_INT({{TYPE}}, unsigned long long, PyLong_AsUnsignedLongLong) 574 } 575 } else { 576#if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 577 #if CYTHON_USE_PYLONG_INTERNALS 578 if (sizeof(digit) <= sizeof({{TYPE}})) { 579 switch (Py_SIZE(x)) { 580 case 0: return 0; 581 case 1: return +({{TYPE}}) ((PyLongObject*)x)->ob_digit[0]; 582 case -1: return -({{TYPE}}) ((PyLongObject*)x)->ob_digit[0]; 583 } 584 } 585 #endif 586#endif 587 if (sizeof({{TYPE}}) <= sizeof(long)) { 588 __PYX_VERIFY_RETURN_INT({{TYPE}}, long, PyLong_AsLong) 589 } else if (sizeof({{TYPE}}) <= sizeof(long long)) { 590 __PYX_VERIFY_RETURN_INT({{TYPE}}, long long, PyLong_AsLongLong) 591 } 592 } 593 { 594#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) 595 PyErr_SetString(PyExc_RuntimeError, 596 "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); 597#else 598 {{TYPE}} val; 599 PyObject *v = __Pyx_PyNumber_Int(x); 600 #if PY_MAJOR_VERSION < 3 601 if (likely(v) && !PyLong_Check(v)) { 602 PyObject *tmp = v; 603 v = PyNumber_Long(tmp); 604 Py_DECREF(tmp); 605 } 606 #endif 607 if (likely(v)) { 608 int one = 1; int is_little = (int)*(unsigned char *)&one; 609 unsigned char *bytes = (unsigned char *)&val; 610 int ret = _PyLong_AsByteArray((PyLongObject *)v, 611 bytes, sizeof(val), 612 is_little, !is_unsigned); 613 Py_DECREF(v); 614 if (likely(!ret)) 615 return val; 616 } 617#endif 618 return ({{TYPE}}) -1; 619 } 620 } else { 621 {{TYPE}} val; 622 PyObject *tmp = __Pyx_PyNumber_Int(x); 623 if (!tmp) return ({{TYPE}}) -1; 624 val = {{FROM_PY_FUNCTION}}(tmp); 625 Py_DECREF(tmp); 626 return val; 627 } 628} 629 630