| /////////////// CModulePreamble /////////////// |
| |
| #include <stddef.h> /* For offsetof */ |
| #ifndef offsetof |
| #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) |
| #endif |
| |
| #if !defined(WIN32) && !defined(MS_WINDOWS) |
| #ifndef __stdcall |
| #define __stdcall |
| #endif |
| #ifndef __cdecl |
| #define __cdecl |
| #endif |
| #ifndef __fastcall |
| #define __fastcall |
| #endif |
| #endif |
| |
| #ifndef DL_IMPORT |
| #define DL_IMPORT(t) t |
| #endif |
| #ifndef DL_EXPORT |
| #define DL_EXPORT(t) t |
| #endif |
| |
| #ifndef PY_LONG_LONG |
| #define PY_LONG_LONG LONG_LONG |
| #endif |
| |
| #ifndef Py_HUGE_VAL |
| #define Py_HUGE_VAL HUGE_VAL |
| #endif |
| |
| #ifdef PYPY_VERSION |
| #define CYTHON_COMPILING_IN_PYPY 1 |
| #define CYTHON_COMPILING_IN_CPYTHON 0 |
| #else |
| #define CYTHON_COMPILING_IN_PYPY 0 |
| #define CYTHON_COMPILING_IN_CPYTHON 1 |
| #endif |
| |
| #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 |
| #define Py_OptimizeFlag 0 |
| #endif |
| |
| #if PY_VERSION_HEX < 0x02050000 |
| typedef int Py_ssize_t; |
| #define PY_SSIZE_T_MAX INT_MAX |
| #define PY_SSIZE_T_MIN INT_MIN |
| #define PY_FORMAT_SIZE_T "" |
| #define CYTHON_FORMAT_SSIZE_T "" |
| #define PyInt_FromSsize_t(z) PyInt_FromLong(z) |
| #define PyInt_AsSsize_t(o) __Pyx_PyInt_As_int(o) |
| #define PyNumber_Index(o) ((PyNumber_Check(o) && !PyFloat_Check(o)) ? PyNumber_Int(o) : \ |
| (PyErr_Format(PyExc_TypeError, \ |
| "expected index value, got %.200s", Py_TYPE(o)->tp_name), \ |
| (PyObject*)0)) |
| #define __Pyx_PyIndex_Check(o) (PyNumber_Check(o) && !PyFloat_Check(o) && \ |
| !PyComplex_Check(o)) |
| #define PyIndex_Check __Pyx_PyIndex_Check |
| #define PyErr_WarnEx(category, message, stacklevel) PyErr_Warn(category, message) |
| #define __PYX_BUILD_PY_SSIZE_T "i" |
| #else |
| #define __PYX_BUILD_PY_SSIZE_T "n" |
| #define CYTHON_FORMAT_SSIZE_T "z" |
| #define __Pyx_PyIndex_Check PyIndex_Check |
| #endif |
| |
| #if PY_VERSION_HEX < 0x02060000 |
| #define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt) |
| #define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) |
| #define Py_SIZE(ob) (((PyVarObject*)(ob))->ob_size) |
| #define PyVarObject_HEAD_INIT(type, size) \ |
| PyObject_HEAD_INIT(type) size, |
| #define PyType_Modified(t) |
| |
| typedef struct { |
| void *buf; |
| PyObject *obj; |
| Py_ssize_t len; |
| Py_ssize_t itemsize; |
| int readonly; |
| int ndim; |
| char *format; |
| Py_ssize_t *shape; |
| Py_ssize_t *strides; |
| Py_ssize_t *suboffsets; |
| void *internal; |
| } Py_buffer; |
| |
| #define PyBUF_SIMPLE 0 |
| #define PyBUF_WRITABLE 0x0001 |
| #define PyBUF_FORMAT 0x0004 |
| #define PyBUF_ND 0x0008 |
| #define PyBUF_STRIDES (0x0010 | PyBUF_ND) |
| #define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES) |
| #define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES) |
| #define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES) |
| #define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES) |
| #define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_FORMAT | PyBUF_WRITABLE) |
| #define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_FORMAT | PyBUF_WRITABLE) |
| |
| typedef int (*getbufferproc)(PyObject *, Py_buffer *, int); |
| typedef void (*releasebufferproc)(PyObject *, Py_buffer *); |
| #endif |
| |
| #if PY_MAJOR_VERSION < 3 |
| #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" |
| #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ |
| PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) |
| #define __Pyx_DefaultClassType PyClass_Type |
| #else |
| #define __Pyx_BUILTIN_MODULE_NAME "builtins" |
| #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) \ |
| PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) |
| #define __Pyx_DefaultClassType PyType_Type |
| #endif |
| |
| #if PY_VERSION_HEX < 0x02060000 |
| #define PyUnicode_FromString(s) PyUnicode_Decode(s, strlen(s), "UTF-8", "strict") |
| #endif |
| |
| #if PY_MAJOR_VERSION >= 3 |
| #define Py_TPFLAGS_CHECKTYPES 0 |
| #define Py_TPFLAGS_HAVE_INDEX 0 |
| #endif |
| |
| #if (PY_VERSION_HEX < 0x02060000) || (PY_MAJOR_VERSION >= 3) |
| #define Py_TPFLAGS_HAVE_NEWBUFFER 0 |
| #endif |
| |
| #if PY_VERSION_HEX < 0x02060000 |
| #define Py_TPFLAGS_HAVE_VERSION_TAG 0 |
| #endif |
| #if PY_VERSION_HEX < 0x02060000 && !defined(Py_TPFLAGS_IS_ABSTRACT) |
| #define Py_TPFLAGS_IS_ABSTRACT 0 |
| #endif |
| #if PY_VERSION_HEX < 0x030400a1 && !defined(Py_TPFLAGS_HAVE_FINALIZE) |
| #define Py_TPFLAGS_HAVE_FINALIZE 0 |
| #endif |
| |
| /* new Py3.3 unicode type (PEP 393) */ |
| #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) |
| #define CYTHON_PEP393_ENABLED 1 |
| #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ? \ |
| 0 : _PyUnicode_Ready((PyObject *)(op))) |
| #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) |
| #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) |
| #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) |
| #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) |
| #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) |
| #else |
| #define CYTHON_PEP393_ENABLED 0 |
| #define __Pyx_PyUnicode_READY(op) (0) |
| #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) |
| #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) |
| #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) |
| #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) |
| /* (void)(k) => avoid unused variable warning due to macro: */ |
| #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) |
| #endif |
| |
| #if CYTHON_COMPILING_IN_PYPY |
| #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) |
| #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) |
| #else |
| #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) |
| #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ? \ |
| PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) |
| #endif |
| |
| #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) |
| #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) |
| |
| #if PY_MAJOR_VERSION >= 3 |
| #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) |
| #else |
| #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) |
| #endif |
| |
| #if PY_MAJOR_VERSION >= 3 |
| #define PyBaseString_Type PyUnicode_Type |
| #define PyStringObject PyUnicodeObject |
| #define PyString_Type PyUnicode_Type |
| #define PyString_Check PyUnicode_Check |
| #define PyString_CheckExact PyUnicode_CheckExact |
| #endif |
| |
| #if PY_VERSION_HEX < 0x02060000 |
| #define PyBytesObject PyStringObject |
| #define PyBytes_Type PyString_Type |
| #define PyBytes_Check PyString_Check |
| #define PyBytes_CheckExact PyString_CheckExact |
| #define PyBytes_FromString PyString_FromString |
| #define PyBytes_FromStringAndSize PyString_FromStringAndSize |
| #define PyBytes_FromFormat PyString_FromFormat |
| #define PyBytes_DecodeEscape PyString_DecodeEscape |
| #define PyBytes_AsString PyString_AsString |
| #define PyBytes_AsStringAndSize PyString_AsStringAndSize |
| #define PyBytes_Size PyString_Size |
| #define PyBytes_AS_STRING PyString_AS_STRING |
| #define PyBytes_GET_SIZE PyString_GET_SIZE |
| #define PyBytes_Repr PyString_Repr |
| #define PyBytes_Concat PyString_Concat |
| #define PyBytes_ConcatAndDel PyString_ConcatAndDel |
| #endif |
| |
| #if PY_MAJOR_VERSION >= 3 |
| #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) |
| #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) |
| #else |
| #define __Pyx_PyBaseString_Check(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj) || \ |
| PyString_Check(obj) || PyUnicode_Check(obj)) |
| #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) |
| #endif |
| |
| #if PY_VERSION_HEX < 0x02060000 |
| #define PySet_Check(obj) PyObject_TypeCheck(obj, &PySet_Type) |
| #define PyFrozenSet_Check(obj) PyObject_TypeCheck(obj, &PyFrozenSet_Type) |
| #endif |
| #ifndef PySet_CheckExact |
| #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) |
| #endif |
| |
| #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) |
| |
| #if PY_MAJOR_VERSION >= 3 |
| #define PyIntObject PyLongObject |
| #define PyInt_Type PyLong_Type |
| #define PyInt_Check(op) PyLong_Check(op) |
| #define PyInt_CheckExact(op) PyLong_CheckExact(op) |
| #define PyInt_FromString PyLong_FromString |
| #define PyInt_FromUnicode PyLong_FromUnicode |
| #define PyInt_FromLong PyLong_FromLong |
| #define PyInt_FromSize_t PyLong_FromSize_t |
| #define PyInt_FromSsize_t PyLong_FromSsize_t |
| #define PyInt_AsLong PyLong_AsLong |
| #define PyInt_AS_LONG PyLong_AS_LONG |
| #define PyInt_AsSsize_t PyLong_AsSsize_t |
| #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask |
| #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask |
| #define PyNumber_Int PyNumber_Long |
| #endif |
| |
| #if PY_MAJOR_VERSION >= 3 |
| #define PyBoolObject PyLongObject |
| #endif |
| |
| #if PY_VERSION_HEX < 0x030200A4 |
| typedef long Py_hash_t; |
| #define __Pyx_PyInt_FromHash_t PyInt_FromLong |
| #define __Pyx_PyInt_AsHash_t PyInt_AsLong |
| #else |
| #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t |
| #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t |
| #endif |
| |
| #if (PY_MAJOR_VERSION < 3) || (PY_VERSION_HEX >= 0x03010300) |
| #define __Pyx_PySequence_GetSlice(obj, a, b) PySequence_GetSlice(obj, a, b) |
| #define __Pyx_PySequence_SetSlice(obj, a, b, value) PySequence_SetSlice(obj, a, b, value) |
| #define __Pyx_PySequence_DelSlice(obj, a, b) PySequence_DelSlice(obj, a, b) |
| #else |
| #define __Pyx_PySequence_GetSlice(obj, a, b) (unlikely(!(obj)) ? \ |
| (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), (PyObject*)0) : \ |
| (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_GetSlice(obj, a, b)) : \ |
| (PyErr_Format(PyExc_TypeError, "'%.200s' object is unsliceable", (obj)->ob_type->tp_name), (PyObject*)0))) |
| #define __Pyx_PySequence_SetSlice(obj, a, b, value) (unlikely(!(obj)) ? \ |
| (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), -1) : \ |
| (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_SetSlice(obj, a, b, value)) : \ |
| (PyErr_Format(PyExc_TypeError, "'%.200s' object doesn't support slice assignment", (obj)->ob_type->tp_name), -1))) |
| #define __Pyx_PySequence_DelSlice(obj, a, b) (unlikely(!(obj)) ? \ |
| (PyErr_SetString(PyExc_SystemError, "null argument to internal routine"), -1) : \ |
| (likely((obj)->ob_type->tp_as_mapping) ? (PySequence_DelSlice(obj, a, b)) : \ |
| (PyErr_Format(PyExc_TypeError, "'%.200s' object doesn't support slice deletion", (obj)->ob_type->tp_name), -1))) |
| #endif |
| |
| #if PY_MAJOR_VERSION >= 3 |
| #define PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) |
| #endif |
| |
| #if PY_VERSION_HEX < 0x02050000 |
| #define __Pyx_GetAttrString(o,n) PyObject_GetAttrString((o),((char *)(n))) |
| #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),((char *)(n)),(a)) |
| #define __Pyx_DelAttrString(o,n) PyObject_DelAttrString((o),((char *)(n))) |
| #else |
| #define __Pyx_GetAttrString(o,n) PyObject_GetAttrString((o),(n)) |
| #define __Pyx_SetAttrString(o,n,a) PyObject_SetAttrString((o),(n),(a)) |
| #define __Pyx_DelAttrString(o,n) PyObject_DelAttrString((o),(n)) |
| #endif |
| |
| #if PY_VERSION_HEX < 0x02050000 |
| #define __Pyx_NAMESTR(n) ((char *)(n)) |
| #define __Pyx_DOCSTR(n) ((char *)(n)) |
| #else |
| #define __Pyx_NAMESTR(n) (n) |
| #define __Pyx_DOCSTR(n) (n) |
| #endif |
| |
| /* inline attribute */ |
| #ifndef CYTHON_INLINE |
| #if defined(__GNUC__) |
| #define CYTHON_INLINE __inline__ |
| #elif defined(_MSC_VER) |
| #define CYTHON_INLINE __inline |
| #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L |
| #define CYTHON_INLINE inline |
| #else |
| #define CYTHON_INLINE |
| #endif |
| #endif |
| |
| /* restrict */ |
| #ifndef CYTHON_RESTRICT |
| #if defined(__GNUC__) |
| #define CYTHON_RESTRICT __restrict__ |
| #elif defined(_MSC_VER) && _MSC_VER >= 1400 |
| #define CYTHON_RESTRICT __restrict |
| #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L |
| #define CYTHON_RESTRICT restrict |
| #else |
| #define CYTHON_RESTRICT |
| #endif |
| #endif |
| |
| #ifdef NAN |
| #define __PYX_NAN() ((float) NAN) |
| #else |
| static CYTHON_INLINE float __PYX_NAN() { |
| /* Initialize NaN. The sign is irrelevant, an exponent with all bits 1 and |
| a nonzero mantissa means NaN. If the first bit in the mantissa is 1, it is |
| a quiet NaN. */ |
| float value; |
| memset(&value, 0xFF, sizeof(value)); |
| return value; |
| } |
| #endif |
| |
| // Work around clang bug http://stackoverflow.com/questions/21847816/c-invoke-nested-template-class-destructor |
| #ifdef __cplusplus |
| template<typename T> |
| void __Pyx_call_destructor(T* x) { |
| x->~T(); |
| } |
| #endif |
| |
| /////////////// UtilityFunctionPredeclarations.proto /////////////// |
| |
| /* unused attribute */ |
| #ifndef CYTHON_UNUSED |
| # if defined(__GNUC__) |
| # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) |
| # define CYTHON_UNUSED __attribute__ ((__unused__)) |
| # else |
| # define CYTHON_UNUSED |
| # endif |
| # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) |
| # define CYTHON_UNUSED __attribute__ ((__unused__)) |
| # else |
| # define CYTHON_UNUSED |
| # endif |
| #endif |
| |
| typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; |
| const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; /*proto*/ |
| |
| /////////////// ForceInitThreads.proto /////////////// |
| |
| #ifndef __PYX_FORCE_INIT_THREADS |
| #define __PYX_FORCE_INIT_THREADS 0 |
| #endif |
| |
| /////////////// InitThreads.init /////////////// |
| |
| #ifdef WITH_THREAD |
| PyEval_InitThreads(); |
| #endif |
| |
| /////////////// CodeObjectCache.proto /////////////// |
| |
| typedef struct { |
| int code_line; |
| PyCodeObject* code_object; |
| } __Pyx_CodeObjectCacheEntry; |
| |
| struct __Pyx_CodeObjectCache { |
| int count; |
| int max_count; |
| __Pyx_CodeObjectCacheEntry* entries; |
| }; |
| |
| static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; |
| |
| static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); |
| static PyCodeObject *__pyx_find_code_object(int code_line); |
| static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); |
| |
| /////////////// CodeObjectCache /////////////// |
| // Note that errors are simply ignored in the code below. |
| // This is just a cache, if a lookup or insertion fails - so what? |
| |
| static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { |
| int start = 0, mid = 0, end = count - 1; |
| if (end >= 0 && code_line > entries[end].code_line) { |
| return count; |
| } |
| while (start < end) { |
| mid = (start + end) / 2; |
| if (code_line < entries[mid].code_line) { |
| end = mid; |
| } else if (code_line > entries[mid].code_line) { |
| start = mid + 1; |
| } else { |
| return mid; |
| } |
| } |
| if (code_line <= entries[mid].code_line) { |
| return mid; |
| } else { |
| return mid + 1; |
| } |
| } |
| |
| static PyCodeObject *__pyx_find_code_object(int code_line) { |
| PyCodeObject* code_object; |
| int pos; |
| if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { |
| return NULL; |
| } |
| pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); |
| if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { |
| return NULL; |
| } |
| code_object = __pyx_code_cache.entries[pos].code_object; |
| Py_INCREF(code_object); |
| return code_object; |
| } |
| |
| static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { |
| int pos, i; |
| __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; |
| if (unlikely(!code_line)) { |
| return; |
| } |
| if (unlikely(!entries)) { |
| entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); |
| if (likely(entries)) { |
| __pyx_code_cache.entries = entries; |
| __pyx_code_cache.max_count = 64; |
| __pyx_code_cache.count = 1; |
| entries[0].code_line = code_line; |
| entries[0].code_object = code_object; |
| Py_INCREF(code_object); |
| } |
| return; |
| } |
| pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); |
| if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { |
| PyCodeObject* tmp = entries[pos].code_object; |
| entries[pos].code_object = code_object; |
| Py_DECREF(tmp); |
| return; |
| } |
| if (__pyx_code_cache.count == __pyx_code_cache.max_count) { |
| int new_max = __pyx_code_cache.max_count + 64; |
| entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( |
| __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); |
| if (unlikely(!entries)) { |
| return; |
| } |
| __pyx_code_cache.entries = entries; |
| __pyx_code_cache.max_count = new_max; |
| } |
| for (i=__pyx_code_cache.count; i>pos; i--) { |
| entries[i] = entries[i-1]; |
| } |
| entries[pos].code_line = code_line; |
| entries[pos].code_object = code_object; |
| __pyx_code_cache.count++; |
| Py_INCREF(code_object); |
| } |
| |
| /////////////// CodeObjectCache.cleanup /////////////// |
| |
| if (__pyx_code_cache.entries) { |
| __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; |
| int i, count = __pyx_code_cache.count; |
| __pyx_code_cache.count = 0; |
| __pyx_code_cache.max_count = 0; |
| __pyx_code_cache.entries = NULL; |
| for (i=0; i<count; i++) { |
| Py_DECREF(entries[i].code_object); |
| } |
| PyMem_Free(entries); |
| } |
| |
| /////////////// CheckBinaryVersion.proto /////////////// |
| |
| static int __Pyx_check_binary_version(void); |
| |
| /////////////// CheckBinaryVersion /////////////// |
| |
| static int __Pyx_check_binary_version(void) { |
| char ctversion[4], rtversion[4]; |
| PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); |
| PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); |
| if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { |
| char message[200]; |
| PyOS_snprintf(message, sizeof(message), |
| "compiletime version %s of module '%.100s' " |
| "does not match runtime version %s", |
| ctversion, __Pyx_MODULE_NAME, rtversion); |
| #if PY_VERSION_HEX < 0x02050000 |
| return PyErr_Warn(NULL, message); |
| #else |
| return PyErr_WarnEx(NULL, message, 1); |
| #endif |
| } |
| return 0; |
| } |
| |
| /////////////// Refnanny.proto /////////////// |
| |
| #ifndef CYTHON_REFNANNY |
| #define CYTHON_REFNANNY 0 |
| #endif |
| |
| #if CYTHON_REFNANNY |
| typedef struct { |
| void (*INCREF)(void*, PyObject*, int); |
| void (*DECREF)(void*, PyObject*, int); |
| void (*GOTREF)(void*, PyObject*, int); |
| void (*GIVEREF)(void*, PyObject*, int); |
| void* (*SetupContext)(const char*, int, const char*); |
| void (*FinishContext)(void**); |
| } __Pyx_RefNannyAPIStruct; |
| static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; |
| static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); /*proto*/ |
| #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; |
| #ifdef WITH_THREAD |
| #define __Pyx_RefNannySetupContext(name, acquire_gil) \ |
| if (acquire_gil) { \ |
| PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure(); \ |
| __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ |
| PyGILState_Release(__pyx_gilstate_save); \ |
| } else { \ |
| __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__); \ |
| } |
| #else |
| #define __Pyx_RefNannySetupContext(name, acquire_gil) \ |
| __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) |
| #endif |
| #define __Pyx_RefNannyFinishContext() \ |
| __Pyx_RefNanny->FinishContext(&__pyx_refnanny) |
| #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) |
| #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) |
| #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) |
| #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) |
| #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) |
| #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) |
| #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) |
| #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) |
| #else |
| #define __Pyx_RefNannyDeclarations |
| #define __Pyx_RefNannySetupContext(name, acquire_gil) |
| #define __Pyx_RefNannyFinishContext() |
| #define __Pyx_INCREF(r) Py_INCREF(r) |
| #define __Pyx_DECREF(r) Py_DECREF(r) |
| #define __Pyx_GOTREF(r) |
| #define __Pyx_GIVEREF(r) |
| #define __Pyx_XINCREF(r) Py_XINCREF(r) |
| #define __Pyx_XDECREF(r) Py_XDECREF(r) |
| #define __Pyx_XGOTREF(r) |
| #define __Pyx_XGIVEREF(r) |
| #endif /* CYTHON_REFNANNY */ |
| |
| #define __Pyx_XDECREF_SET(r, v) do { \ |
| PyObject *tmp = (PyObject *) r; \ |
| r = v; __Pyx_XDECREF(tmp); \ |
| } while (0) |
| #define __Pyx_DECREF_SET(r, v) do { \ |
| PyObject *tmp = (PyObject *) r; \ |
| r = v; __Pyx_DECREF(tmp); \ |
| } while (0) |
| |
| #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) |
| #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) |
| |
| /////////////// Refnanny /////////////// |
| |
| #if CYTHON_REFNANNY |
| static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { |
| PyObject *m = NULL, *p = NULL; |
| void *r = NULL; |
| m = PyImport_ImportModule((char *)modname); |
| if (!m) goto end; |
| p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); |
| if (!p) goto end; |
| r = PyLong_AsVoidPtr(p); |
| end: |
| Py_XDECREF(p); |
| Py_XDECREF(m); |
| return (__Pyx_RefNannyAPIStruct *)r; |
| } |
| #endif /* CYTHON_REFNANNY */ |
| |
| /////////////// RegisterModuleCleanup.proto /////////////// |
| //@substitute: naming |
| |
| static void ${cleanup_cname}(PyObject *self); /*proto*/ |
| static int __Pyx_RegisterCleanup(void); /*proto*/ |
| |
| /////////////// RegisterModuleCleanup /////////////// |
| //@substitute: naming |
| //@requires: ImportExport.c::ModuleImport |
| |
| #if PY_MAJOR_VERSION < 3 |
| static PyObject* ${cleanup_cname}_atexit(PyObject *module, CYTHON_UNUSED PyObject *unused) { |
| ${cleanup_cname}(module); |
| Py_INCREF(Py_None); return Py_None; |
| } |
| |
| static int __Pyx_RegisterCleanup(void) { |
| // Don't use Py_AtExit because that has a 32-call limit and is called |
| // after python finalization. |
| // Also, we try to prepend the cleanup function to "atexit._exithandlers" |
| // in Py2 because CPython runs them last-to-first. Being run last allows |
| // user exit code to run before us that may depend on the globals |
| // and cached objects that we are about to clean up. |
| |
| static PyMethodDef cleanup_def = { |
| __Pyx_NAMESTR("__cleanup"), (PyCFunction)${cleanup_cname}_atexit, METH_NOARGS, 0}; |
| |
| PyObject *cleanup_func = 0; |
| PyObject *atexit = 0; |
| PyObject *reg = 0; |
| PyObject *args = 0; |
| PyObject *res = 0; |
| int ret = -1; |
| |
| cleanup_func = PyCFunction_New(&cleanup_def, 0); |
| if (!cleanup_func) |
| goto bad; |
| |
| atexit = __Pyx_ImportModule("atexit"); |
| if (!atexit) |
| goto bad; |
| reg = __Pyx_GetAttrString(atexit, "_exithandlers"); |
| if (reg && PyList_Check(reg)) { |
| PyObject *a, *kw; |
| a = PyTuple_New(0); |
| kw = PyDict_New(); |
| if (!a || !kw) { |
| Py_XDECREF(a); |
| Py_XDECREF(kw); |
| goto bad; |
| } |
| args = PyTuple_Pack(3, cleanup_func, a, kw); |
| Py_DECREF(a); |
| Py_DECREF(kw); |
| if (!args) |
| goto bad; |
| ret = PyList_Insert(reg, 0, args); |
| } else { |
| if (!reg) |
| PyErr_Clear(); |
| Py_XDECREF(reg); |
| reg = __Pyx_GetAttrString(atexit, "register"); |
| if (!reg) |
| goto bad; |
| args = PyTuple_Pack(1, cleanup_func); |
| if (!args) |
| goto bad; |
| res = PyObject_CallObject(reg, args); |
| if (!res) |
| goto bad; |
| ret = 0; |
| } |
| bad: |
| Py_XDECREF(cleanup_func); |
| Py_XDECREF(atexit); |
| Py_XDECREF(reg); |
| Py_XDECREF(args); |
| Py_XDECREF(res); |
| return ret; |
| } |
| #else |
| // fake call purely to work around "unused function" warning for __Pyx_ImportModule() |
| static int __Pyx_RegisterCleanup(void) { |
| if (0) __Pyx_ImportModule(NULL); |
| return 0; |
| } |
| #endif |
