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
__PYX_NAN()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>
__Pyx_call_destructor(T * x)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
__pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry * entries,int count,int code_line)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
__pyx_find_code_object(int code_line)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
__pyx_insert_code_object(int code_line,PyCodeObject * code_object)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
__Pyx_check_binary_version(void)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
__Pyx_RefNannyImportAPI(const char * modname)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
_atexit(PyObject * module,CYTHON_UNUSED PyObject * unused)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
__Pyx_RegisterCleanup(void)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()
__Pyx_RegisterCleanup(void)689 static int __Pyx_RegisterCleanup(void) {
690 if (0) __Pyx_ImportModule(NULL);
691 return 0;
692 }
693 #endif
694