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

   1 /////////////// CModulePreamble ///////////////
   2
   3 #include <stddef.h> /* For offsetof */
   4 #ifndef offsetof
   5 #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
   6 #endif
   7
   8 #if !defined(WIN32) && !defined(MS_WINDOWS)
   9   #ifndef __stdcall
  10     #define __stdcall
  11   #endif
  12   #ifndef __cdecl
  13     #define __cdecl
  14   #endif
  15   #ifndef __fastcall
  16     #define __fastcall
  17   #endif
  18 #endif
  19
  20 #ifndef DL_IMPORT
  21   #define DL_IMPORT(t) t
  22 #endif
  23 #ifndef DL_EXPORT
  24   #define DL_EXPORT(t) t
  25 #endif
  26
  27 #ifndef PY_LONG_LONG
  28   #define PY_LONG_LONG LONG_LONG
  29 #endif
  30
  31 #ifndef Py_HUGE_VAL
  32   #define Py_HUGE_VAL HUGE_VAL
  33 #endif
  34
  35 #ifdef PYPY_VERSION
  36 #define CYTHON_COMPILING_IN_PYPY 1
  37 #define CYTHON_COMPILING_IN_CPYTHON 0
  38 #else
  39 #define CYTHON_COMPILING_IN_PYPY 0
  40 #define CYTHON_COMPILING_IN_CPYTHON 1
  41 #endif
  42
  43 #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600
  44 #define Py_OptimizeFlag 0
  45 #endif
  46
  47 #if PY_VERSION_HEX < 0x02050000
  48   typedef int Py_ssize_t;
  49   #define PY_SSIZE_T_MAX INT_MAX
  50   #define PY_SSIZE_T_MIN INT_MIN
  51   #define PY_FORMAT_SIZE_T ""
  52   #define CYTHON_FORMAT_SSIZE_T ""
  53   #define PyInt_FromSsize_t(z) PyInt_FromLong(z)
  54   #define PyInt_AsSsize_t(o)   __Pyx_PyInt_As_int(o)
  55   #define PyNumber_Index(o)    ((PyNumber_Check(o) && !PyFloat_Check(o)) ? PyNumber_Int(o) : \
  56                                 (PyErr_Format(PyExc_TypeError, \
  57                                               "expected index value, got %.200s", Py_TYPE(o)->tp_name), \
  58                                  (PyObject*)0))
  59   #define __Pyx_PyIndex_Check(o) (PyNumber_Check(o) && !PyFloat_Check(o) && \
  60                                   !PyComplex_Check(o))
  61   #define PyIndex_Check __Pyx_PyIndex_Check
  62   #define PyErr_WarnEx(category, message, stacklevel) PyErr_Warn(category, message)
  63   #define __PYX_BUILD_PY_SSIZE_T "i"
  64 #else
  65   #define __PYX_BUILD_PY_SSIZE_T "n"
  66   #define CYTHON_FORMAT_SSIZE_T "z"
  67   #define __Pyx_PyIndex_Check PyIndex_Check
  68 #endif
  69
  70 #if PY_VERSION_HEX < 0x02060000
  71   #define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt)
  72   #define Py_TYPE(ob)   (((PyObject*)(ob))->ob_type)
  73   #define Py_SIZE(ob)   (((PyVarObject*)(ob))->ob_size)
  74   #define PyVarObject_HEAD_INIT(type, size) \
  75           PyObject_HEAD_INIT(type) size,
  76   #define PyType_Modified(t)
  77
  78   typedef struct {
  79      void *buf;
  80      PyObject *obj;
  81      Py_ssize_t len;
  82      Py_ssize_t itemsize;
  83      int readonly;
  84      int ndim;
  85      char *format;
  86      Py_ssize_t *shape;
  87      Py_ssize_t *strides;
  88      Py_ssize_t *suboffsets;
  89      void *internal;
  90   } Py_buffer;
  91
  92   #define PyBUF_SIMPLE 0
  93   #define PyBUF_WRITABLE 0x0001
  94   #define PyBUF_FORMAT 0x0004
  95   #define PyBUF_ND 0x0008
  96   #define PyBUF_STRIDES (0x0010 | PyBUF_ND)
  97   #define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)
  98   #define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)
  99   #define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)
 100   #define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)
 101   #define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_FORMAT | PyBUF_WRITABLE)
 102   #define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_FORMAT | PyBUF_WRITABLE)
 103
 104   typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
 105   typedef void (*releasebufferproc)(PyObject *, Py_buffer *);
 106 #endif
 107
 108 #if PY_MAJOR_VERSION < 3
 109   #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
 110   #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \
 111           PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 112   #define __Pyx_DefaultClassType PyClass_Type
 113 #else
 114   #define __Pyx_BUILTIN_MODULE_NAME "builtins"
 115   #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \
 116           PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
 117   #define __Pyx_DefaultClassType PyType_Type
 118 #endif
 119
 120 #if PY_VERSION_HEX < 0x02060000
 121   #define PyUnicode_FromString(s) PyUnicode_Decode(s, strlen(s), "UTF-8", "strict")
 122 #endif
 123
 124 #if PY_MAJOR_VERSION >= 3
 125   #define Py_TPFLAGS_CHECKTYPES 0
 126   #define Py_TPFLAGS_HAVE_INDEX 0
 127 #endif
 128
 129 #if (PY_VERSION_HEX < 0x02060000) || (PY_MAJOR_VERSION >= 3)
 130   #define Py_TPFLAGS_HAVE_NEWBUFFER 0
 131 #endif
 132
 133 #if PY_VERSION_HEX < 0x02060000
 134   #define Py_TPFLAGS_HAVE_VERSION_TAG 0
 135 #endif
 136 #if PY_VERSION_HEX < 0x02060000 && !defined(Py_TPFLAGS_IS_ABSTRACT)
 137   #define Py_TPFLAGS_IS_ABSTRACT 0
 138 #endif
 139 #if PY_VERSION_HEX < 0x030400a1 && !defined(Py_TPFLAGS_HAVE_FINALIZE)
 140   #define Py_TPFLAGS_HAVE_FINALIZE 0
 141 #endif
 142
 143 /* new Py3.3 unicode type (PEP 393) */
 144 #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
 145   #define CYTHON_PEP393_ENABLED 1
 146   #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ? \
 147                                               0 : _PyUnicode_Ready((PyObject *)(op)))
 148   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
 149   #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
 150   #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
 151   #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
 152   #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
 153 #else
 154   #define CYTHON_PEP393_ENABLED 0
 155   #define __Pyx_PyUnicode_READY(op)       (0)
 156   #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
 157   #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
 158   #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
 159   #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
 160   /* (void)(k) => avoid unused variable warning due to macro: */
 161   #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
 162 #endif
 163
 164 #if CYTHON_COMPILING_IN_PYPY
 165   #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
 166   #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
 167 #else
 168   #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
 169   #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ? \
 170       PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
 171 #endif
 172
 173 #define __Pyx_PyString_FormatSafe(a, b)  ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
 174 #define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
 175
 176 #if PY_MAJOR_VERSION >= 3
 177   #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
 178 #else
 179   #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
 180 #endif
 181
 182 #if PY_MAJOR_VERSION >= 3
 183   #define PyBaseString_Type            PyUnicode_Type
 184   #define PyStringObject               PyUnicodeObject
 185   #define PyString_Type                PyUnicode_Type
 186   #define PyString_Check               PyUnicode_Check
 187   #define PyString_CheckExact          PyUnicode_CheckExact
 188 #endif
 189
 190 #if PY_VERSION_HEX < 0x02060000
 191   #define PyBytesObject                PyStringObject
 192   #define PyBytes_Type                 PyString_Type
 193   #define PyBytes_Check                PyString_Check
 194   #define PyBytes_CheckExact           PyString_CheckExact
 195   #define PyBytes_FromString           PyString_FromString
 196   #define PyBytes_FromStringAndSize    PyString_FromStringAndSize
 197   #define PyBytes_FromFormat           PyString_FromFormat
 198   #define PyBytes_DecodeEscape         PyString_DecodeEscape
 199   #define PyBytes_AsString             PyString_AsString
 200   #define PyBytes_AsStringAndSize      PyString_AsStringAndSize
 201   #define PyBytes_Size                 PyString_Size
 202   #define PyBytes_AS_STRING            PyString_AS_STRING
 203   #define PyBytes_GET_SIZE             PyString_GET_SIZE
 204   #define PyBytes_Repr                 PyString_Repr
 205   #define PyBytes_Concat               PyString_Concat
 206   #define PyBytes_ConcatAndDel         PyString_ConcatAndDel
 207 #endif
 208
 209 #if PY_MAJOR_VERSION >= 3
 210   #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
 211   #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
 212 #else
 213   #define __Pyx_PyBaseString_Check(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj) || \
 214                                          PyString_Check(obj) || PyUnicode_Check(obj))
 215   #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
 216 #endif
 217
 218 #if PY_VERSION_HEX < 0x02060000
 219   #define PySet_Check(obj)             PyObject_TypeCheck(obj, &PySet_Type)
 220   #define PyFrozenSet_Check(obj)       PyObject_TypeCheck(obj, &PyFrozenSet_Type)
 221 #endif
 222 #ifndef PySet_CheckExact
 223   #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
 224 #endif
 225
 226 #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
 227
 228 #if PY_MAJOR_VERSION >= 3
 229   #define PyIntObject                  PyLongObject
 230   #define PyInt_Type                   PyLong_Type
 231   #define PyInt_Check(op)              PyLong_Check(op)
 232   #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
 233   #define PyInt_FromString             PyLong_FromString
 234   #define PyInt_FromUnicode            PyLong_FromUnicode
 235   #define PyInt_FromLong               PyLong_FromLong
 236   #define PyInt_FromSize_t             PyLong_FromSize_t
 237   #define PyInt_FromSsize_t            PyLong_FromSsize_t
 238   #define PyInt_AsLong                 PyLong_AsLong
 239   #define PyInt_AS_LONG                PyLong_AS_LONG
 240   #define PyInt_AsSsize_t              PyLong_AsSsize_t
 241   #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
 242   #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
 243   #define PyNumber_Int                 PyNumber_Long
 244 #endif
 245
 246 #if PY_MAJOR_VERSION >= 3
 247   #define PyBoolObject                 PyLongObject
 248 #endif
 249
 250 #if PY_VERSION_HEX < 0x030200A4
 251   typedef long Py_hash_t;
 252   #define __Pyx_PyInt_FromHash_t PyInt_FromLong
 253   #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
 254 #else
 255   #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
 256   #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
 257 #endif
 258
 259 #if (PY_MAJOR_VERSION < 3) || (PY_VERSION_HEX >= 0x03010300)
 260   #define __Pyx_PySequence_GetSlice(obj, a, b) PySequence_GetSlice(obj, a, b)
 261   #define __Pyx_PySequence_SetSlice(obj, a, b, value) PySequence_SetSlice(obj, a, b, value)
 262   #define __Pyx_PySequence_DelSlice(obj, a, b) PySequence_DelSlice(obj, a, b)
 263 #else
 264   #define __Pyx_PySequence_GetSlice(obj, a, b) (unlikely(!(obj)) ? \
 265         (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), (PyObject*)0) : \
 266         (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_GetSlice(obj, a, b)) : \
 267             (PyErr_Format(PyExc_TypeError, "'%.200s' object is unsliceable", (obj)->ob_type->tp_name), (PyObject*)0)))
 268   #define __Pyx_PySequence_SetSlice(obj, a, b, value) (unlikely(!(obj)) ? \
 269         (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), -1) : \
 270         (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_SetSlice(obj, a, b, value)) : \
 271             (PyErr_Format(PyExc_TypeError, "'%.200s' object doesn't support slice assignment", (obj)->ob_type->tp_name), -1)))
 272   #define __Pyx_PySequence_DelSlice(obj, a, b) (unlikely(!(obj)) ? \
 273         (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), -1) : \
 274         (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_DelSlice(obj, a, b)) : \
 275             (PyErr_Format(PyExc_TypeError, "'%.200s' object doesn't support slice deletion", (obj)->ob_type->tp_name), -1)))
 276 #endif
 277
 278 #if PY_MAJOR_VERSION >= 3
 279   #define PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))
 280 #endif
 281
 282 #if PY_VERSION_HEX < 0x02050000
 283   #define __Pyx_GetAttrString(o,n)   PyObject_GetAttrString((o),((char *)(n)))
 284   #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),((char *)(n)),(a))
 285   #define __Pyx_DelAttrString(o,n)   PyObject_DelAttrString((o),((char *)(n)))
 286 #else
 287   #define __Pyx_GetAttrString(o,n)   PyObject_GetAttrString((o),(n))
 288   #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),(n),(a))
 289   #define __Pyx_DelAttrString(o,n)   PyObject_DelAttrString((o),(n))
 290 #endif
 291
 292 #if PY_VERSION_HEX < 0x02050000
 293   #define __Pyx_NAMESTR(n) ((char *)(n))
 294   #define __Pyx_DOCSTR(n)  ((char *)(n))
 295 #else
 296   #define __Pyx_NAMESTR(n) (n)
 297   #define __Pyx_DOCSTR(n)  (n)
 298 #endif
 299
 300 /* inline attribute */
 301 #ifndef CYTHON_INLINE
 302   #if defined(__GNUC__)
 303     #define CYTHON_INLINE __inline__
 304   #elif defined(_MSC_VER)
 305     #define CYTHON_INLINE __inline
 306   #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
 307     #define CYTHON_INLINE inline
 308   #else
 309     #define CYTHON_INLINE
 310   #endif
 311 #endif
 312
 313 /* restrict */
 314 #ifndef CYTHON_RESTRICT
 315   #if defined(__GNUC__)
 316     #define CYTHON_RESTRICT __restrict__
 317   #elif defined(_MSC_VER) && _MSC_VER >= 1400
 318     #define CYTHON_RESTRICT __restrict
 319   #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
 320     #define CYTHON_RESTRICT restrict
 321   #else
 322     #define CYTHON_RESTRICT
 323   #endif
 324 #endif
 325
 326 #ifdef NAN
 327 #define __PYX_NAN() ((float) NAN)
 328 #else
 329 static CYTHON_INLINE float __PYX_NAN() {
 330   /* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and
 331    a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is
 332    a quiet NaN. */
 333   float value;
 334   memset(&value, 0xFF, sizeof(value));
 335   return value;
 336 }
 337 #endif
 338
 339 // Work around clang bug http://stackoverflow.com/questions/21847816/c-invoke-nested-template-class-destructor
 340 #ifdef __cplusplus
 341 template<typename T>
 342 void __Pyx_call_destructor(T* x) {
 343     x->~T();
 344 }
 345 #endif
 346
 347 /////////////// UtilityFunctionPredeclarations.proto ///////////////
 348
 349 /* unused attribute */
 350 #ifndef CYTHON_UNUSED
 351 # if defined(__GNUC__)
 352 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
 353 #     define CYTHON_UNUSED __attribute__ ((__unused__))
 354 #   else
 355 #     define CYTHON_UNUSED
 356 #   endif
 357 # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
 358 #   define CYTHON_UNUSED __attribute__ ((__unused__))
 359 # else
 360 #   define CYTHON_UNUSED
 361 # endif
 362 #endif
 363
 364 typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding;
 365                 const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; /*proto*/
 366
 367 /////////////// ForceInitThreads.proto ///////////////
 368
 369 #ifndef __PYX_FORCE_INIT_THREADS
 370   #define __PYX_FORCE_INIT_THREADS 0
 371 #endif
 372
 373 /////////////// InitThreads.init ///////////////
 374
 375 #ifdef WITH_THREAD
 376 PyEval_InitThreads();
 377 #endif
 378
 379 /////////////// CodeObjectCache.proto ///////////////
 380
 381 typedef struct {
 382     int code_line;
 383     PyCodeObject* code_object;
 384 } __Pyx_CodeObjectCacheEntry;
 385
 386 struct __Pyx_CodeObjectCache {
 387     int count;
 388     int max_count;
 389     __Pyx_CodeObjectCacheEntry* entries;
 390 };
 391
 392 static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
 393
 394 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
 395 static PyCodeObject *__pyx_find_code_object(int code_line);
 396 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
 397
 398 /////////////// CodeObjectCache ///////////////
 399 // Note that errors are simply ignored in the code below.
 400 // This is just a cache, if a lookup or insertion fails - so what?
 401
 402 static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) {
 403     int start = 0, mid = 0, end = count - 1;
 404     if (end >= 0 && code_line > entries[end].code_line) {
 405         return count;
 406     }
 407     while (start < end) {
 408         mid = (start + end) / 2;
 409         if (code_line < entries[mid].code_line) {
 410             end = mid;
 411         } else if (code_line > entries[mid].code_line) {
 412              start = mid + 1;
 413         } else {
 414             return mid;
 415         }
 416     }
 417     if (code_line <= entries[mid].code_line) {
 418         return mid;
 419     } else {
 420         return mid + 1;
 421     }
 422 }
 423
 424 static PyCodeObject *__pyx_find_code_object(int code_line) {
 425     PyCodeObject* code_object;
 426     int pos;
 427     if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) {
 428         return NULL;
 429     }
 430     pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
 431     if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) {
 432         return NULL;
 433     }
 434     code_object = __pyx_code_cache.entries[pos].code_object;
 435     Py_INCREF(code_object);
 436     return code_object;
 437 }
 438
 439 static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
 440     int pos, i;
 441     __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
 442     if (unlikely(!code_line)) {
 443         return;
 444     }
 445     if (unlikely(!entries)) {
 446         entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry));
 447         if (likely(entries)) {
 448             __pyx_code_cache.entries = entries;
 449             __pyx_code_cache.max_count = 64;
 450             __pyx_code_cache.count = 1;
 451             entries[0].code_line = code_line;
 452             entries[0].code_object = code_object;
 453             Py_INCREF(code_object);
 454         }
 455         return;
 456     }
 457     pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line);
 458     if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) {
 459         PyCodeObject* tmp = entries[pos].code_object;
 460         entries[pos].code_object = code_object;
 461         Py_DECREF(tmp);
 462         return;
 463     }
 464     if (__pyx_code_cache.count == __pyx_code_cache.max_count) {
 465         int new_max = __pyx_code_cache.max_count + 64;
 466         entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc(
 467             __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry));
 468         if (unlikely(!entries)) {
 469             return;
 470         }
 471         __pyx_code_cache.entries = entries;
 472         __pyx_code_cache.max_count = new_max;
 473     }
 474     for (i=__pyx_code_cache.count; i>pos; i--) {
 475         entries[i] = entries[i-1];
 476     }
 477     entries[pos].code_line = code_line;
 478     entries[pos].code_object = code_object;
 479     __pyx_code_cache.count++;
 480     Py_INCREF(code_object);
 481 }
 482
 483 /////////////// CodeObjectCache.cleanup ///////////////
 484
 485   if (__pyx_code_cache.entries) {
 486       __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries;
 487       int i, count = __pyx_code_cache.count;
 488       __pyx_code_cache.count = 0;
 489       __pyx_code_cache.max_count = 0;
 490       __pyx_code_cache.entries = NULL;
 491       for (i=0; i<count; i++) {
 492           Py_DECREF(entries[i].code_object);
 493       }
 494       PyMem_Free(entries);
 495   }
 496
 497 /////////////// CheckBinaryVersion.proto ///////////////
 498
 499 static int __Pyx_check_binary_version(void);
 500
 501 /////////////// CheckBinaryVersion ///////////////
 502
 503 static int __Pyx_check_binary_version(void) {
 504     char ctversion[4], rtversion[4];
 505     PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION);
 506     PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion());
 507     if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) {
 508         char message[200];
 509         PyOS_snprintf(message, sizeof(message),
 510                       "compiletime version %s of module '%.100s' "
 511                       "does not match runtime version %s",
 512                       ctversion, __Pyx_MODULE_NAME, rtversion);
 513         #if PY_VERSION_HEX < 0x02050000
 514         return PyErr_Warn(NULL, message);
 515         #else
 516         return PyErr_WarnEx(NULL, message, 1);
 517         #endif
 518     }
 519     return 0;
 520 }
 521
 522 /////////////// Refnanny.proto ///////////////
 523
 524 #ifndef CYTHON_REFNANNY
 525   #define CYTHON_REFNANNY 0
 526 #endif
 527
 528 #if CYTHON_REFNANNY
 529   typedef struct {
 530     void (*INCREF)(void*, PyObject*, int);
 531     void (*DECREF)(void*, PyObject*, int);
 532     void (*GOTREF)(void*, PyObject*, int);
 533     void (*GIVEREF)(void*, PyObject*, int);
 534     void* (*SetupContext)(const char*, int, const char*);
 535     void (*FinishContext)(void**);
 536   } __Pyx_RefNannyAPIStruct;
 537   static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
 538   static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); /*proto*/
 539   #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
 540 #ifdef WITH_THREAD
 541   #define __Pyx_RefNannySetupContext(name, acquire_gil) \
 542           if (acquire_gil) { \
 543               PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \
 544               __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \
 545               PyGILState_Release(__pyx_gilstate_save); \
 546           } else { \
 547               __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \
 548           }
 549 #else
 550   #define __Pyx_RefNannySetupContext(name, acquire_gil) \
 551           __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
 552 #endif
 553   #define __Pyx_RefNannyFinishContext() \
 554           __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
 555   #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
 556   #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
 557   #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
 558   #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
 559   #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
 560   #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
 561   #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
 562   #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
 563 #else
 564   #define __Pyx_RefNannyDeclarations
 565   #define __Pyx_RefNannySetupContext(name, acquire_gil)
 566   #define __Pyx_RefNannyFinishContext()
 567   #define __Pyx_INCREF(r) Py_INCREF(r)
 568   #define __Pyx_DECREF(r) Py_DECREF(r)
 569   #define __Pyx_GOTREF(r)
 570   #define __Pyx_GIVEREF(r)
 571   #define __Pyx_XINCREF(r) Py_XINCREF(r)
 572   #define __Pyx_XDECREF(r) Py_XDECREF(r)
 573   #define __Pyx_XGOTREF(r)
 574   #define __Pyx_XGIVEREF(r)
 575 #endif /* CYTHON_REFNANNY */
 576
 577 #define __Pyx_XDECREF_SET(r, v) do {                            \
 578         PyObject *tmp = (PyObject *) r;                         \
 579         r = v; __Pyx_XDECREF(tmp);                              \
 580     } while (0)
 581 #define __Pyx_DECREF_SET(r, v) do {                             \
 582         PyObject *tmp = (PyObject *) r;                         \
 583         r = v; __Pyx_DECREF(tmp);                               \
 584     } while (0)
 585
 586 #define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
 587 #define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
 588
 589 /////////////// Refnanny ///////////////
 590
 591 #if CYTHON_REFNANNY
 592 static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
 593     PyObject *m = NULL, *p = NULL;
 594     void *r = NULL;
 595     m = PyImport_ImportModule((char *)modname);
 596     if (!m) goto end;
 597     p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");
 598     if (!p) goto end;
 599     r = PyLong_AsVoidPtr(p);
 600 end:
 601     Py_XDECREF(p);
 602     Py_XDECREF(m);
 603     return (__Pyx_RefNannyAPIStruct *)r;
 604 }
 605 #endif /* CYTHON_REFNANNY */
 606
 607 /////////////// RegisterModuleCleanup.proto ///////////////
 608 //@substitute: naming
 609
 610 static void ${cleanup_cname}(PyObject *self); /*proto*/
 611 static int __Pyx_RegisterCleanup(void); /*proto*/
 612
 613 /////////////// RegisterModuleCleanup ///////////////
 614 //@substitute: naming
 615 //@requires: ImportExport.c::ModuleImport
 616
 617 #if PY_MAJOR_VERSION < 3
 618 static PyObject* ${cleanup_cname}_atexit(PyObject *module, CYTHON_UNUSED PyObject *unused) {
 619     ${cleanup_cname}(module);
 620     Py_INCREF(Py_None); return Py_None;
 621 }
 622
 623 static int __Pyx_RegisterCleanup(void) {
 624     // Don't use Py_AtExit because that has a 32-call limit and is called
 625     // after python finalization.
 626     // Also, we try to prepend the cleanup function to "atexit._exithandlers"
 627     // in Py2 because CPython runs them last-to-first. Being run last allows
 628     // user exit code to run before us that may depend on the globals
 629     // and cached objects that we are about to clean up.
 630
 631     static PyMethodDef cleanup_def = {
 632         __Pyx_NAMESTR("__cleanup"), (PyCFunction)${cleanup_cname}_atexit, METH_NOARGS, 0};
 633
 634     PyObject *cleanup_func = 0;
 635     PyObject *atexit = 0;
 636     PyObject *reg = 0;
 637     PyObject *args = 0;
 638     PyObject *res = 0;
 639     int ret = -1;
 640
 641     cleanup_func = PyCFunction_New(&cleanup_def, 0);
 642     if (!cleanup_func)
 643         goto bad;
 644
 645     atexit = __Pyx_ImportModule("atexit");
 646     if (!atexit)
 647         goto bad;
 648     reg = __Pyx_GetAttrString(atexit, "_exithandlers");
 649     if (reg && PyList_Check(reg)) {
 650         PyObject *a, *kw;
 651         a = PyTuple_New(0);
 652         kw = PyDict_New();
 653         if (!a || !kw) {
 654             Py_XDECREF(a);
 655             Py_XDECREF(kw);
 656             goto bad;
 657         }
 658         args = PyTuple_Pack(3, cleanup_func, a, kw);
 659         Py_DECREF(a);
 660         Py_DECREF(kw);
 661         if (!args)
 662             goto bad;
 663         ret = PyList_Insert(reg, 0, args);
 664     } else {
 665         if (!reg)
 666             PyErr_Clear();
 667         Py_XDECREF(reg);
 668         reg = __Pyx_GetAttrString(atexit, "register");
 669         if (!reg)
 670             goto bad;
 671         args = PyTuple_Pack(1, cleanup_func);
 672         if (!args)
 673             goto bad;
 674         res = PyObject_CallObject(reg, args);
 675         if (!res)
 676             goto bad;
 677         ret = 0;
 678     }
 679 bad:
 680     Py_XDECREF(cleanup_func);
 681     Py_XDECREF(atexit);
 682     Py_XDECREF(reg);
 683     Py_XDECREF(args);
 684     Py_XDECREF(res);
 685     return ret;
 686 }
 687 #else
 688 // fake call purely to work around "unused function" warning for __Pyx_ImportModule()
 689 static int __Pyx_RegisterCleanup(void) {
 690     if (0) __Pyx_ImportModule(NULL);
 691     return 0;
 692 }
 693 #endif