1 /////////////// PyIdentifierFromString.proto ///////////////
2
3 #if !defined(__Pyx_PyIdentifier_FromString)
4 #if PY_MAJOR_VERSION < 3
5 #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
6 #else
7 #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
8 #endif
9 #endif
10
11
12 /////////////// Import.proto ///////////////
13
14 static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /*proto*/
15
16 /////////////// Import ///////////////
17 //@requires: ObjectHandling.c::PyObjectGetAttrStr
18 //@substitute: naming
19
__Pyx_Import(PyObject * name,PyObject * from_list,int level)20 static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) {
21 PyObject *empty_list = 0;
22 PyObject *module = 0;
23 PyObject *global_dict = 0;
24 PyObject *empty_dict = 0;
25 PyObject *list;
26 #if PY_VERSION_HEX < 0x03030000
27 PyObject *py_import;
28 py_import = __Pyx_PyObject_GetAttrStr($builtins_cname, PYIDENT("__import__"));
29 if (!py_import)
30 goto bad;
31 #endif
32 if (from_list)
33 list = from_list;
34 else {
35 empty_list = PyList_New(0);
36 if (!empty_list)
37 goto bad;
38 list = empty_list;
39 }
40 global_dict = PyModule_GetDict($module_cname);
41 if (!global_dict)
42 goto bad;
43 empty_dict = PyDict_New();
44 if (!empty_dict)
45 goto bad;
46 #if PY_VERSION_HEX >= 0x02050000
47 {
48 #if PY_MAJOR_VERSION >= 3
49 if (level == -1) {
50 if (strchr(__Pyx_MODULE_NAME, '.')) {
51 /* try package relative import first */
52 #if PY_VERSION_HEX < 0x03030000
53 PyObject *py_level = PyInt_FromLong(1);
54 if (!py_level)
55 goto bad;
56 module = PyObject_CallFunctionObjArgs(py_import,
57 name, global_dict, empty_dict, list, py_level, NULL);
58 Py_DECREF(py_level);
59 #else
60 module = PyImport_ImportModuleLevelObject(
61 name, global_dict, empty_dict, list, 1);
62 #endif
63 if (!module) {
64 if (!PyErr_ExceptionMatches(PyExc_ImportError))
65 goto bad;
66 PyErr_Clear();
67 }
68 }
69 level = 0; /* try absolute import on failure */
70 }
71 #endif
72 if (!module) {
73 #if PY_VERSION_HEX < 0x03030000
74 PyObject *py_level = PyInt_FromLong(level);
75 if (!py_level)
76 goto bad;
77 module = PyObject_CallFunctionObjArgs(py_import,
78 name, global_dict, empty_dict, list, py_level, NULL);
79 Py_DECREF(py_level);
80 #else
81 module = PyImport_ImportModuleLevelObject(
82 name, global_dict, empty_dict, list, level);
83 #endif
84 }
85 }
86 #else
87 if (level>0) {
88 PyErr_SetString(PyExc_RuntimeError, "Relative import is not supported for Python <=2.4.");
89 goto bad;
90 }
91 module = PyObject_CallFunctionObjArgs(py_import,
92 name, global_dict, empty_dict, list, NULL);
93 #endif
94 bad:
95 #if PY_VERSION_HEX < 0x03030000
96 Py_XDECREF(py_import);
97 #endif
98 Py_XDECREF(empty_list);
99 Py_XDECREF(empty_dict);
100 return module;
101 }
102
103
104 /////////////// ImportFrom.proto ///////////////
105
106 static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /*proto*/
107
108 /////////////// ImportFrom ///////////////
109 //@requires: ObjectHandling.c::PyObjectGetAttrStr
110
__Pyx_ImportFrom(PyObject * module,PyObject * name)111 static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) {
112 PyObject* value = __Pyx_PyObject_GetAttrStr(module, name);
113 if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) {
114 PyErr_Format(PyExc_ImportError,
115 #if PY_MAJOR_VERSION < 3
116 "cannot import name %.230s", PyString_AS_STRING(name));
117 #else
118 "cannot import name %S", name);
119 #endif
120 }
121 return value;
122 }
123
124
125 /////////////// ModuleImport.proto ///////////////
126
127 static PyObject *__Pyx_ImportModule(const char *name); /*proto*/
128
129 /////////////// ModuleImport ///////////////
130 //@requires: PyIdentifierFromString
131
132 #ifndef __PYX_HAVE_RT_ImportModule
133 #define __PYX_HAVE_RT_ImportModule
__Pyx_ImportModule(const char * name)134 static PyObject *__Pyx_ImportModule(const char *name) {
135 PyObject *py_name = 0;
136 PyObject *py_module = 0;
137
138 py_name = __Pyx_PyIdentifier_FromString(name);
139 if (!py_name)
140 goto bad;
141 py_module = PyImport_Import(py_name);
142 Py_DECREF(py_name);
143 return py_module;
144 bad:
145 Py_XDECREF(py_name);
146 return 0;
147 }
148 #endif
149
150
151 /////////////// SetPackagePathFromImportLib.proto ///////////////
152
153 #if PY_VERSION_HEX >= 0x03030000
154 static int __Pyx_SetPackagePathFromImportLib(const char* parent_package_name, PyObject *module_name);
155 #else
156 #define __Pyx_SetPackagePathFromImportLib(a, b) 0
157 #endif
158
159 /////////////// SetPackagePathFromImportLib ///////////////
160 //@requires: ObjectHandling.c::PyObjectGetAttrStr
161 //@substitute: naming
162
163 #if PY_VERSION_HEX >= 0x03030000
__Pyx_SetPackagePathFromImportLib(const char * parent_package_name,PyObject * module_name)164 static int __Pyx_SetPackagePathFromImportLib(const char* parent_package_name, PyObject *module_name) {
165 PyObject *importlib, *loader, *osmod, *ossep, *parts, *package_path;
166 PyObject *path = NULL, *file_path = NULL;
167 int result;
168 if (parent_package_name) {
169 PyObject *package = PyImport_ImportModule(parent_package_name);
170 if (unlikely(!package))
171 goto bad;
172 path = PyObject_GetAttrString(package, "__path__");
173 Py_DECREF(package);
174 if (unlikely(!path) || unlikely(path == Py_None))
175 goto bad;
176 } else {
177 path = Py_None; Py_INCREF(Py_None);
178 }
179 // package_path = [importlib.find_loader(module_name, path).path.rsplit(os.sep, 1)[0]]
180 importlib = PyImport_ImportModule("importlib");
181 if (unlikely(!importlib))
182 goto bad;
183 loader = PyObject_CallMethod(importlib, "find_loader", "(OO)", module_name, path);
184 Py_DECREF(importlib);
185 Py_DECREF(path); path = NULL;
186 if (unlikely(!loader))
187 goto bad;
188 file_path = PyObject_GetAttrString(loader, "path");
189 Py_DECREF(loader);
190 if (unlikely(!file_path))
191 goto bad;
192
193 if (unlikely(__Pyx_SetAttrString($module_cname, "__file__", file_path) < 0))
194 goto bad;
195
196 osmod = PyImport_ImportModule("os");
197 if (unlikely(!osmod))
198 goto bad;
199 ossep = PyObject_GetAttrString(osmod, "sep");
200 Py_DECREF(osmod);
201 if (unlikely(!ossep))
202 goto bad;
203 parts = PyObject_CallMethod(file_path, "rsplit", "(Oi)", ossep, 1);
204 Py_DECREF(file_path); file_path = NULL;
205 Py_DECREF(ossep);
206 if (unlikely(!parts))
207 goto bad;
208 package_path = Py_BuildValue("[O]", PyList_GET_ITEM(parts, 0));
209 Py_DECREF(parts);
210 if (unlikely(!package_path))
211 goto bad;
212 goto set_path;
213
214 bad:
215 PyErr_WriteUnraisable(module_name);
216 Py_XDECREF(path);
217 Py_XDECREF(file_path);
218
219 // set an empty path list on failure
220 PyErr_Clear();
221 package_path = PyList_New(0);
222 if (unlikely(!package_path))
223 return -1;
224
225 set_path:
226 result = __Pyx_SetAttrString($module_cname, "__path__", package_path);
227 Py_DECREF(package_path);
228 return result;
229 }
230 #endif
231
232
233 /////////////// TypeImport.proto ///////////////
234
235 static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); /*proto*/
236
237 /////////////// TypeImport ///////////////
238 //@requires: PyIdentifierFromString
239 //@requires: ModuleImport
240
241 #ifndef __PYX_HAVE_RT_ImportType
242 #define __PYX_HAVE_RT_ImportType
__Pyx_ImportType(const char * module_name,const char * class_name,size_t size,int strict)243 static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name,
244 size_t size, int strict)
245 {
246 PyObject *py_module = 0;
247 PyObject *result = 0;
248 PyObject *py_name = 0;
249 char warning[200];
250 Py_ssize_t basicsize;
251 #ifdef Py_LIMITED_API
252 PyObject *py_basicsize;
253 #endif
254
255 py_module = __Pyx_ImportModule(module_name);
256 if (!py_module)
257 goto bad;
258 py_name = __Pyx_PyIdentifier_FromString(class_name);
259 if (!py_name)
260 goto bad;
261 result = PyObject_GetAttr(py_module, py_name);
262 Py_DECREF(py_name);
263 py_name = 0;
264 Py_DECREF(py_module);
265 py_module = 0;
266 if (!result)
267 goto bad;
268 if (!PyType_Check(result)) {
269 PyErr_Format(PyExc_TypeError,
270 "%.200s.%.200s is not a type object",
271 module_name, class_name);
272 goto bad;
273 }
274 #ifndef Py_LIMITED_API
275 basicsize = ((PyTypeObject *)result)->tp_basicsize;
276 #else
277 py_basicsize = PyObject_GetAttrString(result, "__basicsize__");
278 if (!py_basicsize)
279 goto bad;
280 basicsize = PyLong_AsSsize_t(py_basicsize);
281 Py_DECREF(py_basicsize);
282 py_basicsize = 0;
283 if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred())
284 goto bad;
285 #endif
286 if (!strict && (size_t)basicsize > size) {
287 PyOS_snprintf(warning, sizeof(warning),
288 "%s.%s size changed, may indicate binary incompatibility",
289 module_name, class_name);
290 #if PY_VERSION_HEX < 0x02050000
291 if (PyErr_Warn(NULL, warning) < 0) goto bad;
292 #else
293 if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad;
294 #endif
295 }
296 else if ((size_t)basicsize != size) {
297 PyErr_Format(PyExc_ValueError,
298 "%.200s.%.200s has the wrong size, try recompiling",
299 module_name, class_name);
300 goto bad;
301 }
302 return (PyTypeObject *)result;
303 bad:
304 Py_XDECREF(py_module);
305 Py_XDECREF(result);
306 return NULL;
307 }
308 #endif
309
310 /////////////// FunctionImport.proto ///////////////
311
312 static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); /*proto*/
313
314 /////////////// FunctionImport ///////////////
315 //@substitute: naming
316
317 #ifndef __PYX_HAVE_RT_ImportFunction
318 #define __PYX_HAVE_RT_ImportFunction
__Pyx_ImportFunction(PyObject * module,const char * funcname,void (** f)(void),const char * sig)319 static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {
320 PyObject *d = 0;
321 PyObject *cobj = 0;
322 union {
323 void (*fp)(void);
324 void *p;
325 } tmp;
326
327 d = PyObject_GetAttrString(module, (char *)"$api_name");
328 if (!d)
329 goto bad;
330 cobj = PyDict_GetItemString(d, funcname);
331 if (!cobj) {
332 PyErr_Format(PyExc_ImportError,
333 "%.200s does not export expected C function %.200s",
334 PyModule_GetName(module), funcname);
335 goto bad;
336 }
337 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3 && PY_MINOR_VERSION==0)
338 if (!PyCapsule_IsValid(cobj, sig)) {
339 PyErr_Format(PyExc_TypeError,
340 "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
341 PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));
342 goto bad;
343 }
344 tmp.p = PyCapsule_GetPointer(cobj, sig);
345 #else
346 {const char *desc, *s1, *s2;
347 desc = (const char *)PyCObject_GetDesc(cobj);
348 if (!desc)
349 goto bad;
350 s1 = desc; s2 = sig;
351 while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
352 if (*s1 != *s2) {
353 PyErr_Format(PyExc_TypeError,
354 "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
355 PyModule_GetName(module), funcname, sig, desc);
356 goto bad;
357 }
358 tmp.p = PyCObject_AsVoidPtr(cobj);}
359 #endif
360 *f = tmp.fp;
361 if (!(*f))
362 goto bad;
363 Py_DECREF(d);
364 return 0;
365 bad:
366 Py_XDECREF(d);
367 return -1;
368 }
369 #endif
370
371 /////////////// FunctionExport.proto ///////////////
372
373 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); /*proto*/
374
375 /////////////// FunctionExport ///////////////
376 //@substitute: naming
377
__Pyx_ExportFunction(const char * name,void (* f)(void),const char * sig)378 static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) {
379 PyObject *d = 0;
380 PyObject *cobj = 0;
381 union {
382 void (*fp)(void);
383 void *p;
384 } tmp;
385
386 d = PyObject_GetAttrString($module_cname, (char *)"$api_name");
387 if (!d) {
388 PyErr_Clear();
389 d = PyDict_New();
390 if (!d)
391 goto bad;
392 Py_INCREF(d);
393 if (PyModule_AddObject($module_cname, (char *)"$api_name", d) < 0)
394 goto bad;
395 }
396 tmp.fp = f;
397 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
398 cobj = PyCapsule_New(tmp.p, sig, 0);
399 #else
400 cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0);
401 #endif
402 if (!cobj)
403 goto bad;
404 if (PyDict_SetItemString(d, name, cobj) < 0)
405 goto bad;
406 Py_DECREF(cobj);
407 Py_DECREF(d);
408 return 0;
409 bad:
410 Py_XDECREF(cobj);
411 Py_XDECREF(d);
412 return -1;
413 }
414
415 /////////////// VoidPtrImport.proto ///////////////
416
417 static int __Pyx_ImportVoidPtr(PyObject *module, const char *name, void **p, const char *sig); /*proto*/
418
419 /////////////// VoidPtrImport ///////////////
420 //@substitute: naming
421
422 #ifndef __PYX_HAVE_RT_ImportVoidPtr
423 #define __PYX_HAVE_RT_ImportVoidPtr
__Pyx_ImportVoidPtr(PyObject * module,const char * name,void ** p,const char * sig)424 static int __Pyx_ImportVoidPtr(PyObject *module, const char *name, void **p, const char *sig) {
425 PyObject *d = 0;
426 PyObject *cobj = 0;
427
428 d = PyObject_GetAttrString(module, (char *)"$api_name");
429 if (!d)
430 goto bad;
431 cobj = PyDict_GetItemString(d, name);
432 if (!cobj) {
433 PyErr_Format(PyExc_ImportError,
434 "%.200s does not export expected C variable %.200s",
435 PyModule_GetName(module), name);
436 goto bad;
437 }
438 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3 && PY_MINOR_VERSION==0)
439 if (!PyCapsule_IsValid(cobj, sig)) {
440 PyErr_Format(PyExc_TypeError,
441 "C variable %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
442 PyModule_GetName(module), name, sig, PyCapsule_GetName(cobj));
443 goto bad;
444 }
445 *p = PyCapsule_GetPointer(cobj, sig);
446 #else
447 {const char *desc, *s1, *s2;
448 desc = (const char *)PyCObject_GetDesc(cobj);
449 if (!desc)
450 goto bad;
451 s1 = desc; s2 = sig;
452 while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; }
453 if (*s1 != *s2) {
454 PyErr_Format(PyExc_TypeError,
455 "C variable %.200s.%.200s has wrong signature (expected %.500s, got %.500s)",
456 PyModule_GetName(module), name, sig, desc);
457 goto bad;
458 }
459 *p = PyCObject_AsVoidPtr(cobj);}
460 #endif
461 if (!(*p))
462 goto bad;
463 Py_DECREF(d);
464 return 0;
465 bad:
466 Py_XDECREF(d);
467 return -1;
468 }
469 #endif
470
471 /////////////// VoidPtrExport.proto ///////////////
472
473 static int __Pyx_ExportVoidPtr(PyObject *name, void *p, const char *sig); /*proto*/
474
475 /////////////// VoidPtrExport ///////////////
476 //@substitute: naming
477 //@requires: ObjectHandling.c::PyObjectSetAttrStr
478
__Pyx_ExportVoidPtr(PyObject * name,void * p,const char * sig)479 static int __Pyx_ExportVoidPtr(PyObject *name, void *p, const char *sig) {
480 PyObject *d;
481 PyObject *cobj = 0;
482
483 d = PyDict_GetItem($moddict_cname, PYIDENT("$api_name"));
484 Py_XINCREF(d);
485 if (!d) {
486 d = PyDict_New();
487 if (!d)
488 goto bad;
489 if (__Pyx_PyObject_SetAttrStr($module_cname, PYIDENT("$api_name"), d) < 0)
490 goto bad;
491 }
492 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3 && PY_MINOR_VERSION==0)
493 cobj = PyCapsule_New(p, sig, 0);
494 #else
495 cobj = PyCObject_FromVoidPtrAndDesc(p, (void *)sig, 0);
496 #endif
497 if (!cobj)
498 goto bad;
499 if (PyDict_SetItem(d, name, cobj) < 0)
500 goto bad;
501 Py_DECREF(cobj);
502 Py_DECREF(d);
503 return 0;
504 bad:
505 Py_XDECREF(cobj);
506 Py_XDECREF(d);
507 return -1;
508 }
509
510
511 /////////////// SetVTable.proto ///////////////
512
513 static int __Pyx_SetVtable(PyObject *dict, void *vtable); /*proto*/
514
515 /////////////// SetVTable ///////////////
516
__Pyx_SetVtable(PyObject * dict,void * vtable)517 static int __Pyx_SetVtable(PyObject *dict, void *vtable) {
518 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
519 PyObject *ob = PyCapsule_New(vtable, 0, 0);
520 #else
521 PyObject *ob = PyCObject_FromVoidPtr(vtable, 0);
522 #endif
523 if (!ob)
524 goto bad;
525 if (PyDict_SetItem(dict, PYIDENT("__pyx_vtable__"), ob) < 0)
526 goto bad;
527 Py_DECREF(ob);
528 return 0;
529 bad:
530 Py_XDECREF(ob);
531 return -1;
532 }
533
534
535 /////////////// GetVTable.proto ///////////////
536
537 static void* __Pyx_GetVtable(PyObject *dict); /*proto*/
538
539 /////////////// GetVTable ///////////////
540
__Pyx_GetVtable(PyObject * dict)541 static void* __Pyx_GetVtable(PyObject *dict) {
542 void* ptr;
543 PyObject *ob = PyObject_GetItem(dict, PYIDENT("__pyx_vtable__"));
544 if (!ob)
545 goto bad;
546 #if PY_VERSION_HEX >= 0x02070000 && !(PY_MAJOR_VERSION==3&&PY_MINOR_VERSION==0)
547 ptr = PyCapsule_GetPointer(ob, 0);
548 #else
549 ptr = PyCObject_AsVoidPtr(ob);
550 #endif
551 if (!ptr && !PyErr_Occurred())
552 PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type");
553 Py_DECREF(ob);
554 return ptr;
555 bad:
556 Py_XDECREF(ob);
557 return NULL;
558 }
559