1
/* ----------------------------------------------------------------------------
2
* This file was automatically generated by SWIG (http://www.swig.org).
3
* Version 2.0.1+capsulehack
5
* This file is not intended to be easily readable and contains a number of
6
* coding conventions designed to improve portability and efficiency. Do not make
7
* changes to this file unless you know what you are doing--modify the SWIG
8
* interface file instead.
9
* ----------------------------------------------------------------------------- */
12
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
16
/* SwigValueWrapper is described in swig.swg */
17
template<typename T> class SwigValueWrapper {
18
struct SwigMovePointer {
20
SwigMovePointer(T *p) : ptr(p) { }
21
~SwigMovePointer() { delete ptr; }
22
SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
24
SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25
SwigValueWrapper(const SwigValueWrapper<T>& rhs);
27
SwigValueWrapper() : pointer(0) { }
28
SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
29
operator T&() const { return *pointer.ptr; }
30
T *operator&() { return pointer.ptr; }
33
template <typename T> T SwigValueInit() {
38
/* -----------------------------------------------------------------------------
39
* This section contains generic SWIG labels for method/variable
40
* declarations/attributes, and other compiler dependent labels.
41
* ----------------------------------------------------------------------------- */
43
/* template workaround for compilers that cannot correctly implement the C++ standard */
44
#ifndef SWIGTEMPLATEDISAMBIGUATOR
45
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
46
# define SWIGTEMPLATEDISAMBIGUATOR template
47
# elif defined(__HP_aCC)
48
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
49
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
50
# define SWIGTEMPLATEDISAMBIGUATOR template
52
# define SWIGTEMPLATEDISAMBIGUATOR
56
/* inline attribute */
58
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
59
# define SWIGINLINE inline
65
/* attribute recognised by some compilers to avoid 'unused' warnings */
67
# if defined(__GNUC__)
68
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
69
# define SWIGUNUSED __attribute__ ((__unused__))
74
# define SWIGUNUSED __attribute__ ((__unused__))
80
#ifndef SWIG_MSC_UNSUPPRESS_4505
81
# if defined(_MSC_VER)
82
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
86
#ifndef SWIGUNUSEDPARM
88
# define SWIGUNUSEDPARM(p)
90
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
94
/* internal SWIG method */
96
# define SWIGINTERN static SWIGUNUSED
99
/* internal inline SWIG method */
100
#ifndef SWIGINTERNINLINE
101
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
104
/* exporting methods */
105
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
106
# ifndef GCC_HASCLASSVISIBILITY
107
# define GCC_HASCLASSVISIBILITY
112
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
113
# if defined(STATIC_LINKED)
116
# define SWIGEXPORT __declspec(dllexport)
119
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
120
# define SWIGEXPORT __attribute__ ((visibility("default")))
127
/* calling conventions for Windows */
129
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
130
# define SWIGSTDCALL __stdcall
136
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
137
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
138
# define _CRT_SECURE_NO_DEPRECATE
141
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
142
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
143
# define _SCL_SECURE_NO_DEPRECATE
148
/* Python.h has to appear first */
151
/* -----------------------------------------------------------------------------
154
* This file contains generic C API SWIG runtime support for pointer
156
* ----------------------------------------------------------------------------- */
158
/* This should only be incremented when either the layout of swig_type_info changes,
159
or for whatever reason, the runtime changes incompatibly */
160
#define SWIG_RUNTIME_VERSION "4"
162
/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
163
#ifdef SWIG_TYPE_TABLE
164
# define SWIG_QUOTE_STRING(x) #x
165
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
166
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
168
# define SWIG_TYPE_TABLE_NAME
172
You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
173
creating a static or dynamic library from the SWIG runtime code.
174
In 99.9% of the cases, SWIG just needs to declare them as 'static'.
176
But only do this if strictly necessary, ie, if you have problems
177
with your compiler or suchlike.
181
# define SWIGRUNTIME SWIGINTERN
184
#ifndef SWIGRUNTIMEINLINE
185
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
188
/* Generic buffer size */
189
#ifndef SWIG_BUFFER_SIZE
190
# define SWIG_BUFFER_SIZE 1024
193
/* Flags for pointer conversions */
194
#define SWIG_POINTER_DISOWN 0x1
195
#define SWIG_CAST_NEW_MEMORY 0x2
197
/* Flags for new pointer objects */
198
#define SWIG_POINTER_OWN 0x1
202
Flags/methods for returning states.
204
The SWIG conversion methods, as ConvertPtr, return an integer
205
that tells if the conversion was successful or not. And if not,
206
an error code can be returned (see swigerrors.swg for the codes).
208
Use the following macros/flags to set or process the returning
211
In old versions of SWIG, code such as the following was usually written:
213
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
219
Now you can be more explicit:
221
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
222
if (SWIG_IsOK(res)) {
228
which is the same really, but now you can also do
231
int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
232
if (SWIG_IsOK(res)) {
234
if (SWIG_IsNewObj(res) {
244
I.e., now SWIG_ConvertPtr can return new objects and you can
245
identify the case and take care of the deallocation. Of course that
246
also requires SWIG_ConvertPtr to return new result values, such as
248
int SWIG_ConvertPtr(obj, ptr,...) {
250
if (<need new object>) {
251
*ptr = <ptr to new allocated object>;
254
*ptr = <ptr to old object>;
262
Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
263
more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
266
Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
267
allows to return the 'cast rank', for example, if you have this
274
food(1) // cast rank '1' (1 -> 1.0)
275
fooi(1) // cast rank '0'
277
just use the SWIG_AddCast()/SWIG_CheckState()
281
#define SWIG_ERROR (-1)
282
#define SWIG_IsOK(r) (r >= 0)
283
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
285
/* The CastRankLimit says how many bits are used for the cast rank */
286
#define SWIG_CASTRANKLIMIT (1 << 8)
287
/* The NewMask denotes the object was created (using new/malloc) */
288
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
289
/* The TmpMask is for in/out typemaps that use temporal objects */
290
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
291
/* Simple returning values */
292
#define SWIG_BADOBJ (SWIG_ERROR)
293
#define SWIG_OLDOBJ (SWIG_OK)
294
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
295
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
296
/* Check, add and del mask methods */
297
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
298
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
299
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
300
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
301
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
302
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
305
#if defined(SWIG_CASTRANK_MODE)
306
# ifndef SWIG_TypeRank
307
# define SWIG_TypeRank unsigned long
309
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
310
# define SWIG_MAXCASTRANK (2)
312
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
313
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
314
SWIGINTERNINLINE int SWIG_AddCast(int r) {
315
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
317
SWIGINTERNINLINE int SWIG_CheckState(int r) {
318
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
320
#else /* no cast-rank mode */
321
# define SWIG_AddCast
322
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
332
typedef void *(*swig_converter_func)(void *, int *);
333
typedef struct swig_type_info *(*swig_dycast_func)(void **);
335
/* Structure to store information on one type */
336
typedef struct swig_type_info {
337
const char *name; /* mangled name of this type */
338
const char *str; /* human readable name of this type */
339
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
340
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
341
void *clientdata; /* language specific type data */
342
int owndata; /* flag if the structure owns the clientdata */
345
/* Structure to store a type and conversion function used for casting */
346
typedef struct swig_cast_info {
347
swig_type_info *type; /* pointer to type that is equivalent to this type */
348
swig_converter_func converter; /* function to cast the void pointers */
349
struct swig_cast_info *next; /* pointer to next cast in linked list */
350
struct swig_cast_info *prev; /* pointer to the previous cast */
353
/* Structure used to store module information
354
* Each module generates one structure like this, and the runtime collects
355
* all of these structures and stores them in a circularly linked list.*/
356
typedef struct swig_module_info {
357
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
358
size_t size; /* Number of types in this module */
359
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
360
swig_type_info **type_initial; /* Array of initially generated type structures */
361
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
362
void *clientdata; /* Language specific module data */
366
Compare two type names skipping the space characters, therefore
367
"char*" == "char *" and "Class<int>" == "Class<int >", etc.
369
Return 0 when the two name types are equivalent, as in
370
strncmp, but skipping ' '.
373
SWIG_TypeNameComp(const char *f1, const char *l1,
374
const char *f2, const char *l2) {
375
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
376
while ((*f1 == ' ') && (f1 != l1)) ++f1;
377
while ((*f2 == ' ') && (f2 != l2)) ++f2;
378
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
380
return (int)((l1 - f1) - (l2 - f2));
384
Check type equivalence in a name list like <name1>|<name2>|...
385
Return 0 if not equal, 1 if equal
388
SWIG_TypeEquiv(const char *nb, const char *tb) {
390
const char* te = tb + strlen(tb);
392
while (!equiv && *ne) {
393
for (nb = ne; *ne; ++ne) {
394
if (*ne == '|') break;
396
equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
403
Check type equivalence in a name list like <name1>|<name2>|...
404
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
407
SWIG_TypeCompare(const char *nb, const char *tb) {
409
const char* te = tb + strlen(tb);
411
while (!equiv && *ne) {
412
for (nb = ne; *ne; ++ne) {
413
if (*ne == '|') break;
415
equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
425
SWIGRUNTIME swig_cast_info *
426
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
428
swig_cast_info *iter = ty->cast;
430
if (strcmp(iter->type->name, c) == 0) {
431
if (iter == ty->cast)
433
/* Move iter to the top of the linked list */
434
iter->prev->next = iter->next;
436
iter->next->prev = iter->prev;
437
iter->next = ty->cast;
439
if (ty->cast) ty->cast->prev = iter;
450
Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
452
SWIGRUNTIME swig_cast_info *
453
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
455
swig_cast_info *iter = ty->cast;
457
if (iter->type == from) {
458
if (iter == ty->cast)
460
/* Move iter to the top of the linked list */
461
iter->prev->next = iter->next;
463
iter->next->prev = iter->prev;
464
iter->next = ty->cast;
466
if (ty->cast) ty->cast->prev = iter;
477
Cast a pointer up an inheritance hierarchy
479
SWIGRUNTIMEINLINE void *
480
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
481
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
485
Dynamic pointer casting. Down an inheritance hierarchy
487
SWIGRUNTIME swig_type_info *
488
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
489
swig_type_info *lastty = ty;
490
if (!ty || !ty->dcast) return ty;
491
while (ty && (ty->dcast)) {
492
ty = (*ty->dcast)(ptr);
499
Return the name associated with this type
501
SWIGRUNTIMEINLINE const char *
502
SWIG_TypeName(const swig_type_info *ty) {
507
Return the pretty name associated with this type,
508
that is an unmangled type name in a form presentable to the user.
510
SWIGRUNTIME const char *
511
SWIG_TypePrettyName(const swig_type_info *type) {
512
/* The "str" field contains the equivalent pretty names of the
513
type, separated by vertical-bar characters. We choose
514
to print the last name, as it is often (?) the most
516
if (!type) return NULL;
517
if (type->str != NULL) {
518
const char *last_name = type->str;
520
for (s = type->str; *s; s++)
521
if (*s == '|') last_name = s+1;
529
Set the clientdata field for a type
532
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
533
swig_cast_info *cast = ti->cast;
534
/* if (ti->clientdata == clientdata) return; */
535
ti->clientdata = clientdata;
538
if (!cast->converter) {
539
swig_type_info *tc = cast->type;
540
if (!tc->clientdata) {
541
SWIG_TypeClientData(tc, clientdata);
548
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
549
SWIG_TypeClientData(ti, clientdata);
554
Search for a swig_type_info structure only by mangled name
555
Search is a O(log #types)
557
We start searching at module start, and finish searching when start == end.
558
Note: if start == end at the beginning of the function, we go all the way around
561
SWIGRUNTIME swig_type_info *
562
SWIG_MangledTypeQueryModule(swig_module_info *start,
563
swig_module_info *end,
565
swig_module_info *iter = start;
568
register size_t l = 0;
569
register size_t r = iter->size - 1;
571
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
572
register size_t i = (l + r) >> 1;
573
const char *iname = iter->types[i]->name;
575
register int compare = strcmp(name, iname);
577
return iter->types[i];
578
} else if (compare < 0) {
584
} else if (compare > 0) {
588
break; /* should never happen */
593
} while (iter != end);
598
Search for a swig_type_info structure for either a mangled name or a human readable name.
599
It first searches the mangled names of the types, which is a O(log #types)
600
If a type is not found it then searches the human readable names, which is O(#types).
602
We start searching at module start, and finish searching when start == end.
603
Note: if start == end at the beginning of the function, we go all the way around
606
SWIGRUNTIME swig_type_info *
607
SWIG_TypeQueryModule(swig_module_info *start,
608
swig_module_info *end,
610
/* STEP 1: Search the name field using binary search */
611
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
615
/* STEP 2: If the type hasn't been found, do a complete search
616
of the str field (the human readable name) */
617
swig_module_info *iter = start;
619
register size_t i = 0;
620
for (; i < iter->size; ++i) {
621
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
622
return iter->types[i];
625
} while (iter != end);
628
/* neither found a match */
633
Pack binary data into a string
636
SWIG_PackData(char *c, void *ptr, size_t sz) {
637
static const char hex[17] = "0123456789abcdef";
638
register const unsigned char *u = (unsigned char *) ptr;
639
register const unsigned char *eu = u + sz;
640
for (; u != eu; ++u) {
641
register unsigned char uu = *u;
642
*(c++) = hex[(uu & 0xf0) >> 4];
643
*(c++) = hex[uu & 0xf];
649
Unpack binary data from a string
651
SWIGRUNTIME const char *
652
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
653
register unsigned char *u = (unsigned char *) ptr;
654
register const unsigned char *eu = u + sz;
655
for (; u != eu; ++u) {
656
register char d = *(c++);
657
register unsigned char uu;
658
if ((d >= '0') && (d <= '9'))
659
uu = ((d - '0') << 4);
660
else if ((d >= 'a') && (d <= 'f'))
661
uu = ((d - ('a'-10)) << 4);
665
if ((d >= '0') && (d <= '9'))
667
else if ((d >= 'a') && (d <= 'f'))
668
uu |= (d - ('a'-10));
677
Pack 'void *' into a string buffer.
680
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
682
if ((2*sizeof(void *) + 2) > bsz) return 0;
684
r = SWIG_PackData(r,&ptr,sizeof(void *));
685
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
690
SWIGRUNTIME const char *
691
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
693
if (strcmp(c,"NULL") == 0) {
700
return SWIG_UnpackData(++c,ptr,sizeof(void *));
704
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
706
size_t lname = (name ? strlen(name) : 0);
707
if ((2*sz + 2 + lname) > bsz) return 0;
709
r = SWIG_PackData(r,ptr,sz);
711
strncpy(r,name,lname+1);
718
SWIGRUNTIME const char *
719
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
721
if (strcmp(c,"NULL") == 0) {
728
return SWIG_UnpackData(++c,ptr,sz);
736
#define SWIG_UnknownError -1
737
#define SWIG_IOError -2
738
#define SWIG_RuntimeError -3
739
#define SWIG_IndexError -4
740
#define SWIG_TypeError -5
741
#define SWIG_DivisionByZero -6
742
#define SWIG_OverflowError -7
743
#define SWIG_SyntaxError -8
744
#define SWIG_ValueError -9
745
#define SWIG_SystemError -10
746
#define SWIG_AttributeError -11
747
#define SWIG_MemoryError -12
748
#define SWIG_NullReferenceError -13
752
/* Compatibility macros for Python 3 */
753
#if PY_VERSION_HEX >= 0x03000000
755
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
756
#define PyInt_Check(x) PyLong_Check(x)
757
#define PyInt_AsLong(x) PyLong_AsLong(x)
758
#define PyInt_FromLong(x) PyLong_FromLong(x)
759
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
764
# define Py_TYPE(op) ((op)->ob_type)
767
/* SWIG APIs for compatibility of both Python 2 & 3 */
769
#if PY_VERSION_HEX >= 0x03000000
770
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
772
# define SWIG_Python_str_FromFormat PyString_FromFormat
776
/* Warning: This function will allocate a new string in Python 3,
777
* so please call SWIG_Python_str_DelForPy3(x) to free the space.
780
SWIG_Python_str_AsChar(PyObject *str)
782
#if PY_VERSION_HEX >= 0x03000000
786
str = PyUnicode_AsUTF8String(str);
787
PyBytes_AsStringAndSize(str, &cstr, &len);
788
newstr = (char *) malloc(len+1);
789
memcpy(newstr, cstr, len+1);
793
return PyString_AsString(str);
797
#if PY_VERSION_HEX >= 0x03000000
798
# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
800
# define SWIG_Python_str_DelForPy3(x)
805
SWIG_Python_str_FromChar(const char *c)
807
#if PY_VERSION_HEX >= 0x03000000
808
return PyUnicode_FromString(c);
810
return PyString_FromString(c);
814
/* Add PyOS_snprintf for old Pythons */
815
#if PY_VERSION_HEX < 0x02020000
816
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
817
# define PyOS_snprintf _snprintf
819
# define PyOS_snprintf snprintf
823
/* A crude PyString_FromFormat implementation for old Pythons */
824
#if PY_VERSION_HEX < 0x02020000
826
#ifndef SWIG_PYBUFFER_SIZE
827
# define SWIG_PYBUFFER_SIZE 1024
831
PyString_FromFormat(const char *fmt, ...) {
833
char buf[SWIG_PYBUFFER_SIZE * 2];
836
res = vsnprintf(buf, sizeof(buf), fmt, ap);
838
return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
842
/* Add PyObject_Del for old Pythons */
843
#if PY_VERSION_HEX < 0x01060000
844
# define PyObject_Del(op) PyMem_DEL((op))
847
# define PyObject_DEL PyObject_Del
850
/* A crude PyExc_StopIteration exception for old Pythons */
851
#if PY_VERSION_HEX < 0x02020000
852
# ifndef PyExc_StopIteration
853
# define PyExc_StopIteration PyExc_RuntimeError
855
# ifndef PyObject_GenericGetAttr
856
# define PyObject_GenericGetAttr 0
860
/* Py_NotImplemented is defined in 2.1 and up. */
861
#if PY_VERSION_HEX < 0x02010000
862
# ifndef Py_NotImplemented
863
# define Py_NotImplemented PyExc_RuntimeError
867
/* A crude PyString_AsStringAndSize implementation for old Pythons */
868
#if PY_VERSION_HEX < 0x02010000
869
# ifndef PyString_AsStringAndSize
870
# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
874
/* PySequence_Size for old Pythons */
875
#if PY_VERSION_HEX < 0x02000000
876
# ifndef PySequence_Size
877
# define PySequence_Size PySequence_Length
881
/* PyBool_FromLong for old Pythons */
882
#if PY_VERSION_HEX < 0x02030000
884
PyObject *PyBool_FromLong(long ok)
886
PyObject *result = ok ? Py_True : Py_False;
892
/* Py_ssize_t for old Pythons */
893
/* This code is as recommended by: */
894
/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
895
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
896
typedef int Py_ssize_t;
897
# define PY_SSIZE_T_MAX INT_MAX
898
# define PY_SSIZE_T_MIN INT_MIN
901
/* -----------------------------------------------------------------------------
903
* ----------------------------------------------------------------------------- */
905
SWIGRUNTIME PyObject*
906
SWIG_Python_ErrorType(int code) {
909
case SWIG_MemoryError:
910
type = PyExc_MemoryError;
913
type = PyExc_IOError;
915
case SWIG_RuntimeError:
916
type = PyExc_RuntimeError;
918
case SWIG_IndexError:
919
type = PyExc_IndexError;
922
type = PyExc_TypeError;
924
case SWIG_DivisionByZero:
925
type = PyExc_ZeroDivisionError;
927
case SWIG_OverflowError:
928
type = PyExc_OverflowError;
930
case SWIG_SyntaxError:
931
type = PyExc_SyntaxError;
933
case SWIG_ValueError:
934
type = PyExc_ValueError;
936
case SWIG_SystemError:
937
type = PyExc_SystemError;
939
case SWIG_AttributeError:
940
type = PyExc_AttributeError;
943
type = PyExc_RuntimeError;
950
SWIG_Python_AddErrorMsg(const char* mesg)
954
PyObject *traceback = 0;
956
if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
959
PyObject *old_str = PyObject_Str(value);
963
PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
964
SWIG_Python_str_DelForPy3(tmp);
968
PyErr_SetString(PyExc_RuntimeError, mesg);
972
#if defined(SWIG_PYTHON_NO_THREADS)
973
# if defined(SWIG_PYTHON_THREADS)
974
# undef SWIG_PYTHON_THREADS
977
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
978
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
979
# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
980
# define SWIG_PYTHON_USE_GIL
983
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
984
# ifndef SWIG_PYTHON_INITIALIZE_THREADS
985
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
987
# ifdef __cplusplus /* C++ code */
988
class SWIG_Python_Thread_Block {
990
PyGILState_STATE state;
992
void end() { if (status) { PyGILState_Release(state); status = false;} }
993
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
994
~SWIG_Python_Thread_Block() { end(); }
996
class SWIG_Python_Thread_Allow {
1000
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1001
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1002
~SWIG_Python_Thread_Allow() { end(); }
1004
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1005
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1006
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1007
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1009
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1010
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1011
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1012
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1014
# else /* Old thread way, not implemented, user must provide it */
1015
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1016
# define SWIG_PYTHON_INITIALIZE_THREADS
1018
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1019
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1021
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1022
# define SWIG_PYTHON_THREAD_END_BLOCK
1024
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1025
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1027
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1028
# define SWIG_PYTHON_THREAD_END_ALLOW
1031
#else /* No thread support */
1032
# define SWIG_PYTHON_INITIALIZE_THREADS
1033
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1034
# define SWIG_PYTHON_THREAD_END_BLOCK
1035
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1036
# define SWIG_PYTHON_THREAD_END_ALLOW
1039
/* -----------------------------------------------------------------------------
1040
* Python API portion that goes into the runtime
1041
* ----------------------------------------------------------------------------- */
1050
/* -----------------------------------------------------------------------------
1051
* Constant declarations
1052
* ----------------------------------------------------------------------------- */
1054
/* Constant Types */
1055
#define SWIG_PY_POINTER 4
1056
#define SWIG_PY_BINARY 5
1058
/* Constant information structure */
1059
typedef struct swig_const_info {
1065
swig_type_info **ptype;
1069
/* -----------------------------------------------------------------------------
1070
* Wrapper of PyInstanceMethod_New() used in Python 3
1071
* It is exported to the generated module, used for -fastproxy
1072
* ----------------------------------------------------------------------------- */
1073
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
1075
#if PY_VERSION_HEX >= 0x03000000
1076
return PyInstanceMethod_New(func);
1090
/* -----------------------------------------------------------------------------
1093
* This file contains the runtime support for Python modules
1094
* and includes code for managing global variables and pointer
1097
* ----------------------------------------------------------------------------- */
1099
/* Common SWIG API */
1101
/* for raw pointers */
1102
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1103
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1104
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1105
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
1106
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1107
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1108
#define swig_owntype int
1110
/* for raw packed data */
1111
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1112
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1114
/* for class or struct pointers */
1115
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1116
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1118
/* for C or C++ function pointers */
1119
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1120
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1122
/* for C++ member pointers, ie, member methods */
1123
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1124
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1129
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1130
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1131
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1133
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1134
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1135
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1136
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1137
#define SWIG_fail goto fail
1140
* Python 2.7 and newer and Python 3.1 and newer should use Capsules API instead of
1143
#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
1144
(PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0))
1145
#define USE_CAPSULES
1146
#define TYPE_POINTER_NAME \
1147
((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
1150
/* Runtime API implementation */
1152
/* Error manipulation */
1155
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1156
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1157
PyErr_SetObject(errtype, obj);
1159
SWIG_PYTHON_THREAD_END_BLOCK;
1163
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1164
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1165
PyErr_SetString(errtype, (char *) msg);
1166
SWIG_PYTHON_THREAD_END_BLOCK;
1169
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1171
/* Set a constant value */
1174
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1175
PyDict_SetItemString(d, (char*) name, obj);
1179
/* Append a value to the result obj */
1181
SWIGINTERN PyObject*
1182
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1183
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1186
} else if (result == Py_None) {
1190
if (!PyList_Check(result)) {
1191
PyObject *o2 = result;
1192
result = PyList_New(1);
1193
PyList_SetItem(result, 0, o2);
1195
PyList_Append(result,obj);
1204
} else if (result == Py_None) {
1208
if (!PyTuple_Check(result)) {
1210
result = PyTuple_New(1);
1211
PyTuple_SET_ITEM(result, 0, o2);
1213
o3 = PyTuple_New(1);
1214
PyTuple_SET_ITEM(o3, 0, obj);
1216
result = PySequence_Concat(o2, o3);
1224
/* Unpack the argument tuple */
1227
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1233
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1234
name, (min == max ? "" : "at least "), (int)min);
1238
if (!PyTuple_Check(args)) {
1239
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1242
register Py_ssize_t l = PyTuple_GET_SIZE(args);
1244
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1245
name, (min == max ? "" : "at least "), (int)min, (int)l);
1247
} else if (l > max) {
1248
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1249
name, (min == max ? "" : "at most "), (int)max, (int)l);
1253
for (i = 0; i < l; ++i) {
1254
objs[i] = PyTuple_GET_ITEM(args, i);
1256
for (; l < max; ++l) {
1264
/* A functor is a function object with one single object argument */
1265
#if PY_VERSION_HEX >= 0x02020000
1266
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1268
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1272
Helper for static pointer initialization for both C and C++ code, for example
1273
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1276
#define SWIG_STATIC_POINTER(var) var
1278
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1281
/* -----------------------------------------------------------------------------
1282
* Pointer declarations
1283
* ----------------------------------------------------------------------------- */
1285
/* Flags for new pointer objects */
1286
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1287
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1289
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1298
/* How to access Py_None */
1299
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1300
# ifndef SWIG_PYTHON_NO_BUILD_NONE
1301
# ifndef SWIG_PYTHON_BUILD_NONE
1302
# define SWIG_PYTHON_BUILD_NONE
1307
#ifdef SWIG_PYTHON_BUILD_NONE
1310
# define Py_None SWIG_Py_None()
1312
SWIGRUNTIMEINLINE PyObject *
1315
PyObject *none = Py_BuildValue((char*)"");
1319
SWIGRUNTIME PyObject *
1322
static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1327
/* The python void return value */
1329
SWIGRUNTIMEINLINE PyObject *
1332
PyObject *none = Py_None;
1337
/* SwigPyClientData */
1348
SWIGRUNTIMEINLINE int
1349
SWIG_Python_CheckImplicit(swig_type_info *ty)
1351
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1352
return data ? data->implicitconv : 0;
1355
SWIGRUNTIMEINLINE PyObject *
1356
SWIG_Python_ExceptionType(swig_type_info *desc) {
1357
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1358
PyObject *klass = data ? data->klass : 0;
1359
return (klass ? klass : PyExc_RuntimeError);
1363
SWIGRUNTIME SwigPyClientData *
1364
SwigPyClientData_New(PyObject* obj)
1369
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1370
/* the klass element */
1372
Py_INCREF(data->klass);
1373
/* the newraw method and newargs arguments used to create a new raw instance */
1374
if (PyClass_Check(obj)) {
1376
data->newargs = obj;
1379
#if (PY_VERSION_HEX < 0x02020000)
1382
data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1385
Py_INCREF(data->newraw);
1386
data->newargs = PyTuple_New(1);
1387
PyTuple_SetItem(data->newargs, 0, obj);
1389
data->newargs = obj;
1391
Py_INCREF(data->newargs);
1393
/* the destroy method, aka as the C++ delete method */
1394
data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1395
if (PyErr_Occurred()) {
1399
if (data->destroy) {
1401
Py_INCREF(data->destroy);
1402
flags = PyCFunction_GET_FLAGS(data->destroy);
1404
data->delargs = !(flags & (METH_O));
1411
data->implicitconv = 0;
1417
SwigPyClientData_Del(SwigPyClientData* data)
1419
Py_XDECREF(data->newraw);
1420
Py_XDECREF(data->newargs);
1421
Py_XDECREF(data->destroy);
1424
/* =============== SwigPyObject =====================*/
1434
SWIGRUNTIME PyObject *
1435
SwigPyObject_long(SwigPyObject *v)
1437
return PyLong_FromVoidPtr(v->ptr);
1440
SWIGRUNTIME PyObject *
1441
SwigPyObject_format(const char* fmt, SwigPyObject *v)
1443
PyObject *res = NULL;
1444
PyObject *args = PyTuple_New(1);
1446
if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1447
PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1449
#if PY_VERSION_HEX >= 0x03000000
1450
res = PyUnicode_Format(ofmt,args);
1452
res = PyString_Format(ofmt,args);
1462
SWIGRUNTIME PyObject *
1463
SwigPyObject_oct(SwigPyObject *v)
1465
return SwigPyObject_format("%o",v);
1468
SWIGRUNTIME PyObject *
1469
SwigPyObject_hex(SwigPyObject *v)
1471
return SwigPyObject_format("%x",v);
1474
SWIGRUNTIME PyObject *
1476
SwigPyObject_repr(SwigPyObject *v)
1478
SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1481
const char *name = SWIG_TypePrettyName(v->ty);
1482
PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", name, v);
1485
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1487
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1489
#if PY_VERSION_HEX >= 0x03000000
1490
PyObject *joined = PyUnicode_Concat(repr, nrep);
1495
PyString_ConcatAndDel(&repr,nrep);
1502
SwigPyObject_print(SwigPyObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1506
PyObject *repr = SwigPyObject_repr(v);
1508
PyObject *repr = SwigPyObject_repr(v, NULL);
1511
str = SWIG_Python_str_AsChar(repr);
1513
SWIG_Python_str_DelForPy3(str);
1521
SWIGRUNTIME PyObject *
1522
SwigPyObject_str(SwigPyObject *v)
1524
char result[SWIG_BUFFER_SIZE];
1525
return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1526
SWIG_Python_str_FromChar(result) : 0;
1530
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1534
return (i < j) ? -1 : ((i > j) ? 1 : 0);
1537
/* Added for Python 3.x, would it also be useful for Python 2.x? */
1538
SWIGRUNTIME PyObject*
1539
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1542
if( op != Py_EQ && op != Py_NE ) {
1543
Py_INCREF(Py_NotImplemented);
1544
return Py_NotImplemented;
1546
if( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) )
1555
SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1557
SWIGRUNTIME PyTypeObject*
1558
SwigPyObject_type(void) {
1559
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1563
SWIGRUNTIMEINLINE int
1564
SwigPyObject_Check(PyObject *op) {
1565
return (Py_TYPE(op) == SwigPyObject_type())
1566
|| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1569
SWIGRUNTIME PyObject *
1570
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1573
SwigPyObject_dealloc(PyObject *v)
1575
SwigPyObject *sobj = (SwigPyObject *) v;
1576
PyObject *next = sobj->next;
1577
if (sobj->own == SWIG_POINTER_OWN) {
1578
swig_type_info *ty = sobj->ty;
1579
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1580
PyObject *destroy = data ? data->destroy : 0;
1582
/* destroy is always a VARARGS method */
1584
if (data->delargs) {
1585
/* we need to create a temporary object to carry the destroy operation */
1586
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1587
res = SWIG_Python_CallFunctor(destroy, tmp);
1590
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1591
PyObject *mself = PyCFunction_GET_SELF(destroy);
1592
res = ((*meth)(mself, v));
1596
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1598
const char *name = SWIG_TypePrettyName(ty);
1599
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1607
SWIGRUNTIME PyObject*
1608
SwigPyObject_append(PyObject* v, PyObject* next)
1610
SwigPyObject *sobj = (SwigPyObject *) v;
1613
if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1616
if (!SwigPyObject_Check(next)) {
1621
return SWIG_Py_Void();
1624
SWIGRUNTIME PyObject*
1626
SwigPyObject_next(PyObject* v)
1628
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1631
SwigPyObject *sobj = (SwigPyObject *) v;
1633
Py_INCREF(sobj->next);
1636
return SWIG_Py_Void();
1640
SWIGINTERN PyObject*
1642
SwigPyObject_disown(PyObject *v)
1644
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1647
SwigPyObject *sobj = (SwigPyObject *)v;
1649
return SWIG_Py_Void();
1652
SWIGINTERN PyObject*
1654
SwigPyObject_acquire(PyObject *v)
1656
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1659
SwigPyObject *sobj = (SwigPyObject *)v;
1660
sobj->own = SWIG_POINTER_OWN;
1661
return SWIG_Py_Void();
1664
SWIGINTERN PyObject*
1665
SwigPyObject_own(PyObject *v, PyObject *args)
1668
#if (PY_VERSION_HEX < 0x02020000)
1669
if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1671
if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1678
SwigPyObject *sobj = (SwigPyObject *)v;
1679
PyObject *obj = PyBool_FromLong(sobj->own);
1682
if (PyObject_IsTrue(val)) {
1683
SwigPyObject_acquire(v);
1685
SwigPyObject_disown(v);
1688
if (PyObject_IsTrue(val)) {
1689
SwigPyObject_acquire(v,args);
1691
SwigPyObject_disown(v,args);
1701
swigobject_methods[] = {
1702
{(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1703
{(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1704
{(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1705
{(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1706
{(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1707
{(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1712
swigobject_methods[] = {
1713
{(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1714
{(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1715
{(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1716
{(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1717
{(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1718
{(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1723
#if PY_VERSION_HEX < 0x02020000
1724
SWIGINTERN PyObject *
1725
SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1727
return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1731
SWIGRUNTIME PyTypeObject*
1732
_PySwigObject_type(void) {
1733
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1735
static PyNumberMethods SwigPyObject_as_number = {
1736
(binaryfunc)0, /*nb_add*/
1737
(binaryfunc)0, /*nb_subtract*/
1738
(binaryfunc)0, /*nb_multiply*/
1739
/* nb_divide removed in Python 3 */
1740
#if PY_VERSION_HEX < 0x03000000
1741
(binaryfunc)0, /*nb_divide*/
1743
(binaryfunc)0, /*nb_remainder*/
1744
(binaryfunc)0, /*nb_divmod*/
1745
(ternaryfunc)0,/*nb_power*/
1746
(unaryfunc)0, /*nb_negative*/
1747
(unaryfunc)0, /*nb_positive*/
1748
(unaryfunc)0, /*nb_absolute*/
1749
(inquiry)0, /*nb_nonzero*/
1756
#if PY_VERSION_HEX < 0x03000000
1759
(unaryfunc)SwigPyObject_long, /*nb_int*/
1760
#if PY_VERSION_HEX < 0x03000000
1761
(unaryfunc)SwigPyObject_long, /*nb_long*/
1765
(unaryfunc)0, /*nb_float*/
1766
#if PY_VERSION_HEX < 0x03000000
1767
(unaryfunc)SwigPyObject_oct, /*nb_oct*/
1768
(unaryfunc)SwigPyObject_hex, /*nb_hex*/
1770
#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1771
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1772
#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1773
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1774
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1775
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1776
#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1777
0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1781
static PyTypeObject swigpyobject_type;
1782
static int type_init = 0;
1784
const PyTypeObject tmp
1786
/* PyObject header changed in Python 3 */
1787
#if PY_VERSION_HEX >= 0x03000000
1788
PyVarObject_HEAD_INIT(&PyType_Type, 0)
1790
PyObject_HEAD_INIT(NULL)
1793
(char *)"SwigPyObject", /* tp_name */
1794
sizeof(SwigPyObject), /* tp_basicsize */
1795
0, /* tp_itemsize */
1796
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
1797
(printfunc)SwigPyObject_print, /* tp_print */
1798
#if PY_VERSION_HEX < 0x02020000
1799
(getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1801
(getattrfunc)0, /* tp_getattr */
1803
(setattrfunc)0, /* tp_setattr */
1804
#if PY_VERSION_HEX >= 0x03000000
1805
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1807
(cmpfunc)SwigPyObject_compare, /* tp_compare */
1809
(reprfunc)SwigPyObject_repr, /* tp_repr */
1810
&SwigPyObject_as_number, /* tp_as_number */
1811
0, /* tp_as_sequence */
1812
0, /* tp_as_mapping */
1813
(hashfunc)0, /* tp_hash */
1814
(ternaryfunc)0, /* tp_call */
1815
(reprfunc)SwigPyObject_str, /* tp_str */
1816
PyObject_GenericGetAttr, /* tp_getattro */
1817
0, /* tp_setattro */
1818
0, /* tp_as_buffer */
1819
Py_TPFLAGS_DEFAULT, /* tp_flags */
1820
swigobject_doc, /* tp_doc */
1821
0, /* tp_traverse */
1823
(richcmpfunc)SwigPyObject_richcompare, /* tp_richcompare */
1824
0, /* tp_weaklistoffset */
1825
#if PY_VERSION_HEX >= 0x02020000
1827
0, /* tp_iternext */
1828
swigobject_methods, /* tp_methods */
1833
0, /* tp_descr_get */
1834
0, /* tp_descr_set */
1835
0, /* tp_dictoffset */
1844
0, /* tp_subclasses */
1845
0, /* tp_weaklist */
1847
#if PY_VERSION_HEX >= 0x02030000
1851
0,0,0,0 /* tp_alloc -> tp_next */
1854
swigpyobject_type = tmp;
1855
/* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
1856
#if PY_VERSION_HEX < 0x03000000
1857
swigpyobject_type.ob_type = &PyType_Type;
1861
return &swigpyobject_type;
1864
SWIGRUNTIME PyObject *
1865
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1867
SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
1874
return (PyObject *)sobj;
1877
/* -----------------------------------------------------------------------------
1878
* Implements a simple Swig Packed type, and use it instead of string
1879
* ----------------------------------------------------------------------------- */
1889
SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1891
char result[SWIG_BUFFER_SIZE];
1892
fputs("<Swig Packed ", fp);
1893
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1897
fputs(v->ty->name,fp);
1902
SWIGRUNTIME PyObject *
1903
SwigPyPacked_repr(SwigPyPacked *v)
1905
char result[SWIG_BUFFER_SIZE];
1906
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1907
return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1909
return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
1913
SWIGRUNTIME PyObject *
1914
SwigPyPacked_str(SwigPyPacked *v)
1916
char result[SWIG_BUFFER_SIZE];
1917
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1918
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
1920
return SWIG_Python_str_FromChar(v->ty->name);
1925
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
1929
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1930
return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1933
SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1935
SWIGRUNTIME PyTypeObject*
1936
SwigPyPacked_type(void) {
1937
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1941
SWIGRUNTIMEINLINE int
1942
SwigPyPacked_Check(PyObject *op) {
1943
return ((op)->ob_type == _PySwigPacked_type())
1944
|| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
1948
SwigPyPacked_dealloc(PyObject *v)
1950
if (SwigPyPacked_Check(v)) {
1951
SwigPyPacked *sobj = (SwigPyPacked *) v;
1957
SWIGRUNTIME PyTypeObject*
1958
_PySwigPacked_type(void) {
1959
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1960
static PyTypeObject swigpypacked_type;
1961
static int type_init = 0;
1963
const PyTypeObject tmp
1965
/* PyObject header changed in Python 3 */
1966
#if PY_VERSION_HEX>=0x03000000
1967
PyVarObject_HEAD_INIT(&PyType_Type, 0)
1969
PyObject_HEAD_INIT(NULL)
1972
(char *)"SwigPyPacked", /* tp_name */
1973
sizeof(SwigPyPacked), /* tp_basicsize */
1974
0, /* tp_itemsize */
1975
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
1976
(printfunc)SwigPyPacked_print, /* tp_print */
1977
(getattrfunc)0, /* tp_getattr */
1978
(setattrfunc)0, /* tp_setattr */
1979
#if PY_VERSION_HEX>=0x03000000
1980
0, /* tp_reserved in 3.0.1 */
1982
(cmpfunc)SwigPyPacked_compare, /* tp_compare */
1984
(reprfunc)SwigPyPacked_repr, /* tp_repr */
1985
0, /* tp_as_number */
1986
0, /* tp_as_sequence */
1987
0, /* tp_as_mapping */
1988
(hashfunc)0, /* tp_hash */
1989
(ternaryfunc)0, /* tp_call */
1990
(reprfunc)SwigPyPacked_str, /* tp_str */
1991
PyObject_GenericGetAttr, /* tp_getattro */
1992
0, /* tp_setattro */
1993
0, /* tp_as_buffer */
1994
Py_TPFLAGS_DEFAULT, /* tp_flags */
1995
swigpacked_doc, /* tp_doc */
1996
0, /* tp_traverse */
1998
0, /* tp_richcompare */
1999
0, /* tp_weaklistoffset */
2000
#if PY_VERSION_HEX >= 0x02020000
2002
0, /* tp_iternext */
2008
0, /* tp_descr_get */
2009
0, /* tp_descr_set */
2010
0, /* tp_dictoffset */
2019
0, /* tp_subclasses */
2020
0, /* tp_weaklist */
2022
#if PY_VERSION_HEX >= 0x02030000
2026
0,0,0,0 /* tp_alloc -> tp_next */
2029
swigpypacked_type = tmp;
2030
/* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
2031
#if PY_VERSION_HEX < 0x03000000
2032
swigpypacked_type.ob_type = &PyType_Type;
2036
return &swigpypacked_type;
2039
SWIGRUNTIME PyObject *
2040
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2042
SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2044
void *pack = malloc(size);
2046
memcpy(pack, ptr, size);
2051
PyObject_DEL((PyObject *) sobj);
2055
return (PyObject *) sobj;
2058
SWIGRUNTIME swig_type_info *
2059
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2061
if (SwigPyPacked_Check(obj)) {
2062
SwigPyPacked *sobj = (SwigPyPacked *)obj;
2063
if (sobj->size != size) return 0;
2064
memcpy(ptr, sobj->pack, size);
2071
/* -----------------------------------------------------------------------------
2072
* pointers/data manipulation
2073
* ----------------------------------------------------------------------------- */
2075
SWIGRUNTIMEINLINE PyObject *
2078
return SWIG_Python_str_FromChar("this");
2081
static PyObject *swig_this = NULL;
2083
SWIGRUNTIME PyObject *
2086
if (swig_this == NULL)
2087
swig_this = _SWIG_This();
2091
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2093
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
2094
#if PY_VERSION_HEX>=0x03000000
2095
#define SWIG_PYTHON_SLOW_GETSET_THIS
2098
SWIGRUNTIME SwigPyObject *
2099
SWIG_Python_GetSwigThis(PyObject *pyobj)
2101
if (SwigPyObject_Check(pyobj)) {
2102
return (SwigPyObject *) pyobj;
2105
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2106
if (PyInstance_Check(pyobj)) {
2107
obj = _PyInstance_Lookup(pyobj, SWIG_This());
2109
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2110
if (dictptr != NULL) {
2111
PyObject *dict = *dictptr;
2112
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2114
#ifdef PyWeakref_CheckProxy
2115
if (PyWeakref_CheckProxy(pyobj)) {
2116
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2117
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2120
obj = PyObject_GetAttr(pyobj,SWIG_This());
2124
if (PyErr_Occurred()) PyErr_Clear();
2130
obj = PyObject_GetAttr(pyobj,SWIG_This());
2134
if (PyErr_Occurred()) PyErr_Clear();
2138
if (obj && !SwigPyObject_Check(obj)) {
2139
/* a PyObject is called 'this', try to get the 'real this'
2140
SwigPyObject from it */
2141
return SWIG_Python_GetSwigThis(obj);
2143
return (SwigPyObject *)obj;
2147
/* Acquire a pointer value */
2150
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2151
if (own == SWIG_POINTER_OWN) {
2152
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2154
int oldown = sobj->own;
2162
/* Convert a pointer value */
2165
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2166
if (!obj) return SWIG_ERROR;
2167
if (obj == Py_None) {
2171
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2175
void *vptr = sobj->ptr;
2177
swig_type_info *to = sobj->ty;
2179
/* no type cast needed */
2180
if (ptr) *ptr = vptr;
2183
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2185
sobj = (SwigPyObject *)sobj->next;
2189
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2190
if (newmemory == SWIG_CAST_NEW_MEMORY) {
2191
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2193
*own = *own | SWIG_CAST_NEW_MEMORY;
2200
if (ptr) *ptr = vptr;
2206
*own = *own | sobj->own;
2207
if (flags & SWIG_POINTER_DISOWN) {
2212
int res = SWIG_ERROR;
2213
if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2214
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2215
if (data && !data->implicitconv) {
2216
PyObject *klass = data->klass;
2219
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2220
impconv = SWIG_Python_CallFunctor(klass, obj);
2221
data->implicitconv = 0;
2222
if (PyErr_Occurred()) {
2227
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2230
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2231
if (SWIG_IsOK(res)) {
2234
/* transfer the ownership to 'ptr' */
2236
res = SWIG_AddCast(res);
2237
res = SWIG_AddNewMask(res);
2239
res = SWIG_AddCast(res);
2253
/* Convert a function ptr value */
2256
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2257
if (!PyCFunction_Check(obj)) {
2258
return SWIG_ConvertPtr(obj, ptr, ty, 0);
2262
/* here we get the method pointer for callbacks */
2263
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2264
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2266
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2270
swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2273
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2274
assert(!newmemory); /* newmemory handling not yet implemented */
2285
/* Convert a packed value value */
2288
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2289
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2290
if (!to) return SWIG_ERROR;
2293
/* check type cast? */
2294
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2295
if (!tc) return SWIG_ERROR;
2301
/* -----------------------------------------------------------------------------
2302
* Create a new pointer object
2303
* ----------------------------------------------------------------------------- */
2306
Create a new instance object, without calling __init__, and set the
2310
SWIGRUNTIME PyObject*
2311
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2313
#if (PY_VERSION_HEX >= 0x02020000)
2315
PyObject *newraw = data->newraw;
2317
inst = PyObject_Call(newraw, data->newargs, NULL);
2319
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2320
PyObject **dictptr = _PyObject_GetDictPtr(inst);
2321
if (dictptr != NULL) {
2322
PyObject *dict = *dictptr;
2324
dict = PyDict_New();
2326
PyDict_SetItem(dict, SWIG_This(), swig_this);
2330
PyObject *key = SWIG_This();
2331
PyObject_SetAttr(inst, key, swig_this);
2335
#if PY_VERSION_HEX >= 0x03000000
2336
inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2337
PyObject_SetAttr(inst, SWIG_This(), swig_this);
2338
Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2340
PyObject *dict = PyDict_New();
2341
PyDict_SetItem(dict, SWIG_This(), swig_this);
2342
inst = PyInstance_NewRaw(data->newargs, dict);
2348
#if (PY_VERSION_HEX >= 0x02010000)
2350
PyObject *dict = PyDict_New();
2351
PyDict_SetItem(dict, SWIG_This(), swig_this);
2352
inst = PyInstance_NewRaw(data->newargs, dict);
2354
return (PyObject *) inst;
2356
PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2360
inst->in_class = (PyClassObject *)data->newargs;
2361
Py_INCREF(inst->in_class);
2362
inst->in_dict = PyDict_New();
2363
if (inst->in_dict == NULL) {
2367
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2368
inst->in_weakreflist = NULL;
2370
#ifdef Py_TPFLAGS_GC
2371
PyObject_GC_Init(inst);
2373
PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2374
return (PyObject *) inst;
2380
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2383
#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2384
PyObject **dictptr = _PyObject_GetDictPtr(inst);
2385
if (dictptr != NULL) {
2388
dict = PyDict_New();
2391
PyDict_SetItem(dict, SWIG_This(), swig_this);
2395
dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2396
PyDict_SetItem(dict, SWIG_This(), swig_this);
2401
SWIGINTERN PyObject *
2402
SWIG_Python_InitShadowInstance(PyObject *args) {
2404
if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2407
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2409
SwigPyObject_append((PyObject*) sthis, obj[1]);
2411
SWIG_Python_SetSwigThis(obj[0], obj[1]);
2413
return SWIG_Py_Void();
2417
/* Create a new pointer object */
2419
SWIGRUNTIME PyObject *
2420
SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2422
return SWIG_Py_Void();
2424
int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2425
PyObject *robj = SwigPyObject_New(ptr, type, own);
2426
SwigPyClientData *clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2427
if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2428
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2438
/* Create a new packed object */
2440
SWIGRUNTIMEINLINE PyObject *
2441
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2442
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2445
/* -----------------------------------------------------------------------------*
2447
* -----------------------------------------------------------------------------*/
2449
#ifdef SWIG_LINK_RUNTIME
2450
void *SWIG_ReturnGlobalTypeList(void *);
2453
SWIGRUNTIME swig_module_info *
2454
SWIG_Python_GetModule(void) {
2455
static void *type_pointer = (void *)0;
2456
/* first check if module already created */
2457
if (!type_pointer) {
2458
#ifdef SWIG_LINK_RUNTIME
2459
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2462
type_pointer = PyCapsule_Import(TYPE_POINTER_NAME, 0);
2464
type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2465
(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2467
if (PyErr_Occurred()) {
2469
type_pointer = (void *)0;
2473
return (swig_module_info *) type_pointer;
2476
#if PY_MAJOR_VERSION < 2
2477
/* PyModule_AddObject function was introduced in Python 2.0. The following function
2478
is copied out of Python/modsupport.c in python version 2.3.4 */
2480
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2483
if (!PyModule_Check(m)) {
2484
PyErr_SetString(PyExc_TypeError,
2485
"PyModule_AddObject() needs module as first arg");
2489
PyErr_SetString(PyExc_TypeError,
2490
"PyModule_AddObject() needs non-NULL value");
2494
dict = PyModule_GetDict(m);
2496
/* Internal error -- modules must have a dict! */
2497
PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2498
PyModule_GetName(m));
2501
if (PyDict_SetItemString(dict, name, o))
2509
SWIG_Python_DestroyModule(void *vptr)
2513
swig_module_info *swig_module =
2514
(swig_module_info *) PyCapsule_GetPointer((PyObject *)vptr, TYPE_POINTER_NAME);
2516
swig_module_info *swig_module = (swig_module_info *) vptr;
2518
swig_type_info **types = swig_module->types;
2519
for (i =0; i < swig_module->size; ++i) {
2520
swig_type_info *ty = types[i];
2522
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2523
if (data) SwigPyClientData_Del(data);
2526
Py_DECREF(SWIG_This());
2531
SWIG_Python_SetModule(swig_module_info *swig_module) {
2532
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2534
#if PY_VERSION_HEX >= 0x03000000
2535
/* Add a dummy module object into sys.modules */
2536
PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2538
PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2539
swig_empty_runtime_method_table);
2542
PyObject *pointer = PyCapsule_New((void *)swig_module, TYPE_POINTER_NAME,
2543
(PyCapsule_Destructor)SWIG_Python_DestroyModule);
2545
PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2547
if (pointer && module) {
2549
PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2551
PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2554
Py_XDECREF(pointer);
2558
/* The python cached type query */
2559
SWIGRUNTIME PyObject *
2560
SWIG_Python_TypeCache(void) {
2561
static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2565
SWIGRUNTIME swig_type_info *
2566
SWIG_Python_TypeQuery(const char *type)
2568
PyObject *cache = SWIG_Python_TypeCache();
2569
PyObject *key = SWIG_Python_str_FromChar(type);
2570
PyObject *obj = PyDict_GetItem(cache, key);
2571
swig_type_info *descriptor;
2574
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, type);
2576
descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2579
swig_module_info *swig_module = SWIG_Python_GetModule();
2580
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2583
obj = PyCapsule_New(descriptor, type, NULL);
2585
obj = PyCObject_FromVoidPtr(descriptor, NULL);
2587
PyDict_SetItem(cache, key, obj);
2596
For backward compatibility only
2598
#define SWIG_POINTER_EXCEPTION 0
2599
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2600
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2603
SWIG_Python_AddErrMesg(const char* mesg, int infront)
2605
if (PyErr_Occurred()) {
2607
PyObject *value = 0;
2608
PyObject *traceback = 0;
2609
PyErr_Fetch(&type, &value, &traceback);
2612
PyObject *old_str = PyObject_Str(value);
2616
PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2618
PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2620
SWIG_Python_str_DelForPy3(tmp);
2630
SWIG_Python_ArgFail(int argnum)
2632
if (PyErr_Occurred()) {
2633
/* add information about failing argument */
2635
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2636
return SWIG_Python_AddErrMesg(mesg, 1);
2642
SWIGRUNTIMEINLINE const char *
2643
SwigPyObject_GetDesc(PyObject *self)
2645
SwigPyObject *v = (SwigPyObject *)self;
2646
swig_type_info *ty = v ? v->ty : 0;
2647
return ty ? ty->str : (char*)"";
2651
SWIG_Python_TypeError(const char *type, PyObject *obj)
2654
#if defined(SWIG_COBJECT_TYPES)
2655
if (obj && SwigPyObject_Check(obj)) {
2656
const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2658
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2665
const char *otype = (obj ? obj->ob_type->tp_name : 0);
2667
PyObject *str = PyObject_Str(obj);
2668
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2670
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2672
SWIG_Python_str_DelForPy3(cstr);
2674
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2681
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2683
PyErr_Format(PyExc_TypeError, "unexpected type is received");
2688
/* Convert a pointer value, signal an exception on a type mismatch */
2690
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2692
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2694
#if SWIG_POINTER_EXCEPTION
2696
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2697
SWIG_Python_ArgFail(argnum);
2714
#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2716
#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2720
/* -------- TYPES TABLE (BEGIN) -------- */
2722
#define SWIGTYPE_p_char swig_types[0]
2723
static swig_type_info *swig_types[2];
2724
static swig_module_info swig_module = {swig_types, 1, 0, 0, 0, 0};
2725
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2726
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2728
/* -------- TYPES TABLE (END) -------- */
2730
#if (PY_VERSION_HEX <= 0x02000000)
2731
# if !defined(SWIG_PYTHON_CLASSIC)
2732
# error "This python version requires swig to be run with the '-classic' option"
2736
/*-----------------------------------------------
2737
@(target):= _csgraph.so
2738
------------------------------------------------*/
2739
#if PY_VERSION_HEX >= 0x03000000
2740
# define SWIG_init PyInit__csgraph
2743
# define SWIG_init init_csgraph
2746
#define SWIG_name "_csgraph"
2748
#define SWIGVERSION 0x020001
2749
#define SWIG_VERSION SWIGVERSION
2752
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2753
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2756
#include <stdexcept>
2760
class SwigPtr_PyObject {
2765
SwigPtr_PyObject() :_obj(0)
2769
SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
2774
SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
2781
SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
2783
Py_XINCREF(item._obj);
2794
operator PyObject *() const
2799
PyObject *operator->() const
2808
struct SwigVar_PyObject : SwigPtr_PyObject {
2809
SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
2811
SwigVar_PyObject & operator = (PyObject* obj)
2822
#define SWIG_FILE_WITH_INIT
2824
#include "numpy/arrayobject.h"
2825
#include "complex_ops.h"
2826
/*#include "sparsetools.h"*/
2829
#ifndef SWIG_FILE_WITH_INIT
2830
# define NO_IMPORT_ARRAY
2833
#include <numpy/arrayobject.h>
2834
#include "complex_ops.h"
2837
/* The following code originally appeared in
2838
* enthought/kiva/agg/src/numeric.i written by Eric Jones. It was
2839
* translated from C++ to C by John Hunter. Bill Spotz has modified
2840
* it slightly to fix some minor bugs, upgrade to numpy (all
2841
* versions), add some comments and some functionality.
2844
/* Macros to extract array attributes.
2846
#define is_array(a) ((a) && PyArray_Check((PyArrayObject *)a))
2847
#define array_type(a) (int)(PyArray_TYPE(a))
2848
#define array_numdims(a) (((PyArrayObject *)a)->nd)
2849
#define array_dimensions(a) (((PyArrayObject *)a)->dimensions)
2850
#define array_size(a,i) (((PyArrayObject *)a)->dimensions[i])
2851
#define array_data(a) (((PyArrayObject *)a)->data)
2852
#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS(a))
2853
#define array_is_native(a) (PyArray_ISNOTSWAPPED(a))
2855
/* Support older NumPy data type names
2857
#if NDARRAY_VERSION < 0x01000000
2858
#define NPY_BOOL PyArray_BOOL
2859
#define NPY_BYTE PyArray_BYTE
2860
#define NPY_UBYTE PyArray_UBYTE
2861
#define NPY_SHORT PyArray_SHORT
2862
#define NPY_USHORT PyArray_USHORT
2863
#define NPY_INT PyArray_INT
2864
#define NPY_UINT PyArray_UINT
2865
#define NPY_LONG PyArray_LONG
2866
#define NPY_ULONG PyArray_ULONG
2867
#define NPY_LONGLONG PyArray_LONGLONG
2868
#define NPY_ULONGLONG PyArray_ULONGLONG
2869
#define NPY_FLOAT PyArray_FLOAT
2870
#define NPY_DOUBLE PyArray_DOUBLE
2871
#define NPY_LONGDOUBLE PyArray_LONGDOUBLE
2872
#define NPY_CFLOAT PyArray_CFLOAT
2873
#define NPY_CDOUBLE PyArray_CDOUBLE
2874
#define NPY_CLONGDOUBLE PyArray_CLONGDOUBLE
2875
#define NPY_OBJECT PyArray_OBJECT
2876
#define NPY_STRING PyArray_STRING
2877
#define NPY_UNICODE PyArray_UNICODE
2878
#define NPY_VOID PyArray_VOID
2879
#define NPY_NTYPES PyArray_NTYPES
2880
#define NPY_NOTYPE PyArray_NOTYPE
2881
#define NPY_CHAR PyArray_CHAR
2882
#define NPY_USERDEF PyArray_USERDEF
2883
#define npy_intp intp
2886
/* Given a PyObject, return a string describing its type.
2888
const char* pytype_string(PyObject* py_obj) {
2889
if (py_obj == NULL ) return "C NULL value";
2890
if (py_obj == Py_None ) return "Python None" ;
2891
if (PyCallable_Check(py_obj)) return "callable" ;
2892
if (PyString_Check( py_obj)) return "string" ;
2893
if (PyInt_Check( py_obj)) return "int" ;
2894
if (PyFloat_Check( py_obj)) return "float" ;
2895
if (PyDict_Check( py_obj)) return "dict" ;
2896
if (PyList_Check( py_obj)) return "list" ;
2897
if (PyTuple_Check( py_obj)) return "tuple" ;
2898
if (PyFile_Check( py_obj)) return "file" ;
2899
if (PyModule_Check( py_obj)) return "module" ;
2900
if (PyInstance_Check(py_obj)) return "instance" ;
2902
return "unkown type";
2905
/* Given a NumPy typecode, return a string describing the type.
2907
const char* typecode_string(int typecode) {
2908
static const char* type_names[25] = {"bool", "byte", "unsigned byte",
2909
"short", "unsigned short", "int",
2910
"unsigned int", "long", "unsigned long",
2911
"long long", "unsigned long long",
2912
"float", "double", "long double",
2913
"complex float", "complex double",
2914
"complex long double", "object",
2915
"string", "unicode", "void", "ntypes",
2916
"notype", "char", "unknown"};
2917
return typecode < 24 ? type_names[typecode] : type_names[24];
2920
/* Make sure input has correct numpy type. Allow character and byte
2921
* to match. Also allow int and long to match. This is deprecated.
2922
* You should use PyArray_EquivTypenums() instead.
2924
int type_match(int actual_type, int desired_type) {
2925
return PyArray_EquivTypenums(actual_type, desired_type);
2928
/* Given a PyObject pointer, cast it to a PyArrayObject pointer if
2929
* legal. If not, set the python error string appropriately and
2932
PyArrayObject* obj_to_array_no_conversion(PyObject* input, int typecode) {
2933
PyArrayObject* ary = NULL;
2934
if (is_array(input) && (typecode == NPY_NOTYPE ||
2935
PyArray_EquivTypenums(array_type(input), typecode))) {
2936
ary = (PyArrayObject*) input;
2938
else if is_array(input) {
2939
const char* desired_type = typecode_string(typecode);
2940
const char* actual_type = typecode_string(array_type(input));
2941
PyErr_Format(PyExc_TypeError,
2942
"Array of type '%s' required. Array of type '%s' given",
2943
desired_type, actual_type);
2947
const char * desired_type = typecode_string(typecode);
2948
const char * actual_type = pytype_string(input);
2949
PyErr_Format(PyExc_TypeError,
2950
"Array of type '%s' required. A '%s' was given",
2951
desired_type, actual_type);
2957
/* Convert the given PyObject to a NumPy array with the given
2958
* typecode. On success, return a valid PyArrayObject* with the
2959
* correct type. On failure, the python error string will be set and
2960
* the routine returns NULL.
2962
PyArrayObject* obj_to_array_allow_conversion(PyObject* input, int typecode,
2963
int* is_new_object) {
2964
PyArrayObject* ary = NULL;
2966
if (is_array(input) && (typecode == NPY_NOTYPE ||
2967
PyArray_EquivTypenums(array_type(input),typecode))) {
2968
ary = (PyArrayObject*) input;
2972
py_obj = PyArray_FromObject(input, typecode, 0, 0);
2973
/* If NULL, PyArray_FromObject will have set python error value.*/
2974
ary = (PyArrayObject*) py_obj;
2980
/* Given a PyArrayObject, check to see if it is contiguous. If so,
2981
* return the input pointer and flag it as not a new object. If it is
2982
* not contiguous, create a new PyArrayObject using the original data,
2983
* flag it as a new object and return the pointer.
2985
PyArrayObject* make_contiguous(PyArrayObject* ary, int* is_new_object,
2986
int min_dims, int max_dims) {
2987
PyArrayObject* result;
2988
if (array_is_contiguous(ary)) {
2993
result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary,
3002
/* Convert a given PyObject to a contiguous PyArrayObject of the
3003
* specified type. If the input object is not a contiguous
3004
* PyArrayObject, a new one will be created and the new object flag
3007
PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input,
3009
int* is_new_object) {
3012
PyArrayObject* ary2;
3013
PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode, &is_new1);
3015
ary2 = make_contiguous(ary1, &is_new2, 0, 0);
3016
if ( is_new1 && is_new2) {
3021
*is_new_object = is_new1 || is_new2;
3025
/* Test whether a python object is contiguous. If array is
3026
* contiguous, return 1. Otherwise, set the python error string and
3029
int require_contiguous(PyArrayObject* ary) {
3031
if (!array_is_contiguous(ary)) {
3032
PyErr_SetString(PyExc_TypeError,
3033
"Array must be contiguous. A non-contiguous array was given");
3039
/* Require that a numpy array is not byte-swapped. If the array is
3040
* not byte-swapped, return 1. Otherwise, set the python error string
3043
int require_native(PyArrayObject* ary) {
3045
if (!array_is_native(ary)) {
3046
PyErr_SetString(PyExc_TypeError,
3047
"Array must have native byteorder. A byte-swapped array was given");
3053
/* Require the given PyArrayObject to have a specified number of
3054
* dimensions. If the array has the specified number of dimensions,
3055
* return 1. Otherwise, set the python error string and return 0.
3057
int require_dimensions(PyArrayObject* ary, int exact_dimensions) {
3059
if (array_numdims(ary) != exact_dimensions) {
3060
PyErr_Format(PyExc_TypeError,
3061
"Array must have %d dimensions. Given array has %d dimensions",
3062
exact_dimensions, array_numdims(ary));
3068
/* Require the given PyArrayObject to have one of a list of specified
3069
* number of dimensions. If the array has one of the specified number
3070
* of dimensions, return 1. Otherwise, set the python error string
3073
int require_dimensions_n(PyArrayObject* ary, int* exact_dimensions, int n) {
3076
char dims_str[255] = "";
3078
for (i = 0; i < n && !success; i++) {
3079
if (array_numdims(ary) == exact_dimensions[i]) {
3084
for (i = 0; i < n-1; i++) {
3085
sprintf(s, "%d, ", exact_dimensions[i]);
3088
sprintf(s, " or %d", exact_dimensions[n-1]);
3090
PyErr_Format(PyExc_TypeError,
3091
"Array must be have %s dimensions. Given array has %d dimensions",
3092
dims_str, array_numdims(ary));
3097
/* Require the given PyArrayObject to have a specified shape. If the
3098
* array has the specified shape, return 1. Otherwise, set the python
3099
* error string and return 0.
3101
int require_size(PyArrayObject* ary, npy_intp* size, int n) {
3105
char desired_dims[255] = "[";
3107
char actual_dims[255] = "[";
3108
for(i=0; i < n;i++) {
3109
if (size[i] != -1 && size[i] != array_size(ary,i)) {
3114
for (i = 0; i < n; i++) {
3115
if (size[i] == -1) {
3120
sprintf(s,"%" NPY_INTP_FMT ",", size[i]);
3122
strcat(desired_dims,s);
3124
len = strlen(desired_dims);
3125
desired_dims[len-1] = ']';
3126
for (i = 0; i < n; i++) {
3127
sprintf(s,"%" NPY_INTP_FMT ",", array_size(ary,i));
3128
strcat(actual_dims,s);
3130
len = strlen(actual_dims);
3131
actual_dims[len-1] = ']';
3132
PyErr_Format(PyExc_TypeError,
3133
"Array must be have shape of %s. Given array has shape of %s",
3134
desired_dims, actual_dims);
3138
/* End John Hunter translation (with modifications by Bill Spotz) */
3145
Appends @a what to @a where. On input, @a where need not to be a tuple, but on
3146
return it always is.
3148
@par Revision history:
3151
PyObject *helper_appendToTuple( PyObject *where, PyObject *what ) {
3154
if ((!where) || (where == Py_None)) {
3157
if (!PyTuple_Check( where )) {
3159
where = PyTuple_New( 1 );
3160
PyTuple_SetItem( where, 0, o2 );
3162
o3 = PyTuple_New( 1 );
3163
PyTuple_SetItem( o3, 0, what );
3165
where = PySequence_Concat( o2, o3 );
3177
#include "csgraph.h"
3181
#if !defined(SWIG_NO_LLONG_MAX)
3182
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3183
# define LLONG_MAX __LONG_LONG_MAX__
3184
# define LLONG_MIN (-LLONG_MAX - 1LL)
3185
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3191
SWIG_AsVal_double (PyObject *obj, double *val)
3193
int res = SWIG_TypeError;
3194
if (PyFloat_Check(obj)) {
3195
if (val) *val = PyFloat_AsDouble(obj);
3197
} else if (PyInt_Check(obj)) {
3198
if (val) *val = PyInt_AsLong(obj);
3200
} else if (PyLong_Check(obj)) {
3201
double v = PyLong_AsDouble(obj);
3202
if (!PyErr_Occurred()) {
3209
#ifdef SWIG_PYTHON_CAST_MODE
3212
double d = PyFloat_AsDouble(obj);
3213
if (!PyErr_Occurred()) {
3215
return SWIG_AddCast(SWIG_OK);
3220
long v = PyLong_AsLong(obj);
3221
if (!PyErr_Occurred()) {
3223
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3240
SWIGINTERNINLINE int
3241
SWIG_CanCastAsInteger(double *d, double min, double max) {
3243
if ((min <= x && x <= max)) {
3244
double fx = floor(x);
3245
double cx = ceil(x);
3246
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3247
if ((errno == EDOM) || (errno == ERANGE)) {
3250
double summ, reps, diff;
3253
} else if (rd > x) {
3260
if (reps < 8*DBL_EPSILON) {
3271
SWIG_AsVal_long (PyObject *obj, long* val)
3273
if (PyInt_Check(obj)) {
3274
if (val) *val = PyInt_AsLong(obj);
3276
} else if (PyLong_Check(obj)) {
3277
long v = PyLong_AsLong(obj);
3278
if (!PyErr_Occurred()) {
3285
#ifdef SWIG_PYTHON_CAST_MODE
3288
long v = PyInt_AsLong(obj);
3289
if (!PyErr_Occurred()) {
3291
return SWIG_AddCast(SWIG_OK);
3297
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3298
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3299
if (val) *val = (long)(d);
3305
return SWIG_TypeError;
3310
SWIG_AsVal_int (PyObject * obj, int *val)
3313
int res = SWIG_AsVal_long (obj, &v);
3314
if (SWIG_IsOK(res)) {
3315
if ((v < INT_MIN || v > INT_MAX)) {
3316
return SWIG_OverflowError;
3318
if (val) *val = static_cast< int >(v);
3325
#define SWIG_From_long PyInt_FromLong
3328
SWIGINTERNINLINE PyObject *
3329
SWIG_From_int (int value)
3331
return SWIG_From_long (value);
3335
#include "csgraph.h"
3340
SWIGINTERN PyObject *_wrap_cs_graph_components(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3341
PyObject *resultobj = 0;
3348
PyArrayObject *array2 = NULL ;
3349
int is_new_object2 ;
3350
PyArrayObject *array3 = NULL ;
3351
int is_new_object3 ;
3352
PyArrayObject *temp4 = NULL ;
3353
PyObject * obj0 = 0 ;
3354
PyObject * obj1 = 0 ;
3355
PyObject * obj2 = 0 ;
3356
PyObject * obj3 = 0 ;
3359
if (!PyArg_ParseTuple(args,(char *)"OOOO:cs_graph_components",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3360
ecode1 = SWIG_AsVal_int(obj0, &val1);
3361
if (!SWIG_IsOK(ecode1)) {
3362
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cs_graph_components" "', argument " "1"" of type '" "int""'");
3364
arg1 = static_cast< int >(val1);
3366
npy_intp size[1] = {
3369
array2 = obj_to_array_contiguous_allow_conversion(obj1, PyArray_INT, &is_new_object2);
3370
if (!array2 || !require_dimensions(array2,1) || !require_size(array2,size,1)
3371
|| !require_contiguous(array2) || !require_native(array2)) SWIG_fail;
3373
arg2 = (int*) array2->data;
3376
npy_intp size[1] = {
3379
array3 = obj_to_array_contiguous_allow_conversion(obj2, PyArray_INT, &is_new_object3);
3380
if (!array3 || !require_dimensions(array3,1) || !require_size(array3,size,1)
3381
|| !require_contiguous(array3) || !require_native(array3)) SWIG_fail;
3383
arg3 = (int*) array3->data;
3386
temp4 = obj_to_array_no_conversion(obj3,PyArray_INT);
3387
if (!temp4 || !require_contiguous(temp4) || !require_native(temp4)) SWIG_fail;
3388
arg4 = (int*) array_data(temp4);
3390
result = (int)cs_graph_components< int >(arg1,(int const (*))arg2,(int const (*))arg3,arg4);
3391
resultobj = SWIG_From_int(static_cast< int >(result));
3393
if (is_new_object2 && array2) {
3398
if (is_new_object3 && array3) {
3405
if (is_new_object2 && array2) {
3410
if (is_new_object3 && array3) {
3418
static PyMethodDef SwigMethods[] = {
3419
{ (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
3420
{ (char *)"cs_graph_components", _wrap_cs_graph_components, METH_VARARGS, (char *)"cs_graph_components(int n_nod, int Ap, int Aj, int flag) -> int"},
3421
{ NULL, NULL, 0, NULL }
3425
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3427
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
3429
static swig_type_info *swig_type_initial[] = {
3433
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3435
static swig_cast_info *swig_cast_initial[] = {
3440
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3442
static swig_const_info swig_const_table[] = {
3443
{0, 0, 0, 0.0, 0, 0}};
3448
/* -----------------------------------------------------------------------------
3449
* Type initialization:
3450
* This problem is tough by the requirement that no dynamic
3451
* memory is used. Also, since swig_type_info structures store pointers to
3452
* swig_cast_info structures and swig_cast_info structures store pointers back
3453
* to swig_type_info structures, we need some lookup code at initialization.
3454
* The idea is that swig generates all the structures that are needed.
3455
* The runtime then collects these partially filled structures.
3456
* The SWIG_InitializeModule function takes these initial arrays out of
3457
* swig_module, and does all the lookup, filling in the swig_module.types
3458
* array with the correct data and linking the correct swig_cast_info
3459
* structures together.
3461
* The generated swig_type_info structures are assigned staticly to an initial
3462
* array. We just loop through that array, and handle each type individually.
3463
* First we lookup if this type has been already loaded, and if so, use the
3464
* loaded structure instead of the generated one. Then we have to fill in the
3465
* cast linked list. The cast data is initially stored in something like a
3466
* two-dimensional array. Each row corresponds to a type (there are the same
3467
* number of rows as there are in the swig_type_initial array). Each entry in
3468
* a column is one of the swig_cast_info structures for that type.
3469
* The cast_initial array is actually an array of arrays, because each row has
3470
* a variable number of columns. So to actually build the cast linked list,
3471
* we find the array of casts associated with the type, and loop through it
3472
* adding the casts to the list. The one last trick we need to do is making
3473
* sure the type pointer in the swig_cast_info struct is correct.
3475
* First off, we lookup the cast->type name to see if it is already loaded.
3476
* There are three cases to handle:
3477
* 1) If the cast->type has already been loaded AND the type we are adding
3478
* casting info to has not been loaded (it is in this module), THEN we
3479
* replace the cast->type pointer with the type pointer that has already
3481
* 2) If BOTH types (the one we are adding casting info to, and the
3482
* cast->type) are loaded, THEN the cast info has already been loaded by
3483
* the previous module so we just ignore it.
3484
* 3) Finally, if cast->type has not already been loaded, then we add that
3485
* swig_cast_info to the linked list (because the cast->type) pointer will
3487
* ----------------------------------------------------------------------------- */
3497
#define SWIGRUNTIME_DEBUG
3502
SWIG_InitializeModule(void *clientdata) {
3504
swig_module_info *module_head, *iter;
3507
clientdata = clientdata;
3509
/* check to see if the circular list has been setup, if not, set it up */
3510
if (swig_module.next==0) {
3511
/* Initialize the swig_module */
3512
swig_module.type_initial = swig_type_initial;
3513
swig_module.cast_initial = swig_cast_initial;
3514
swig_module.next = &swig_module;
3520
/* Try and load any already created modules */
3521
module_head = SWIG_GetModule(clientdata);
3523
/* This is the first module loaded for this interpreter */
3524
/* so set the swig module into the interpreter */
3525
SWIG_SetModule(clientdata, &swig_module);
3526
module_head = &swig_module;
3528
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
3532
if (iter==&swig_module) {
3537
} while (iter!= module_head);
3539
/* if the is found in the list, then all is done and we may leave */
3541
/* otherwise we must add out module into the list */
3542
swig_module.next = module_head->next;
3543
module_head->next = &swig_module;
3546
/* When multiple interpeters are used, a module could have already been initialized in
3547
a different interpreter, but not yet have a pointer in this interpreter.
3548
In this case, we do not want to continue adding types... everything should be
3550
if (init == 0) return;
3552
/* Now work on filling in swig_module.types */
3553
#ifdef SWIGRUNTIME_DEBUG
3554
printf("SWIG_InitializeModule: size %d\n", swig_module.size);
3556
for (i = 0; i < swig_module.size; ++i) {
3557
swig_type_info *type = 0;
3558
swig_type_info *ret;
3559
swig_cast_info *cast;
3561
#ifdef SWIGRUNTIME_DEBUG
3562
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3565
/* if there is another module already loaded */
3566
if (swig_module.next != &swig_module) {
3567
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3570
/* Overwrite clientdata field */
3571
#ifdef SWIGRUNTIME_DEBUG
3572
printf("SWIG_InitializeModule: found type %s\n", type->name);
3574
if (swig_module.type_initial[i]->clientdata) {
3575
type->clientdata = swig_module.type_initial[i]->clientdata;
3576
#ifdef SWIGRUNTIME_DEBUG
3577
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3581
type = swig_module.type_initial[i];
3584
/* Insert casting types */
3585
cast = swig_module.cast_initial[i];
3586
while (cast->type) {
3587
/* Don't need to add information already in the list */
3589
#ifdef SWIGRUNTIME_DEBUG
3590
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
3592
if (swig_module.next != &swig_module) {
3593
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
3594
#ifdef SWIGRUNTIME_DEBUG
3595
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
3599
if (type == swig_module.type_initial[i]) {
3600
#ifdef SWIGRUNTIME_DEBUG
3601
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
3606
/* Check for casting already in the list */
3607
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
3608
#ifdef SWIGRUNTIME_DEBUG
3609
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
3611
if (!ocast) ret = 0;
3616
#ifdef SWIGRUNTIME_DEBUG
3617
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
3620
type->cast->prev = cast;
3621
cast->next = type->cast;
3627
/* Set entry in modules->types array equal to the type */
3628
swig_module.types[i] = type;
3630
swig_module.types[i] = 0;
3632
#ifdef SWIGRUNTIME_DEBUG
3633
printf("**** SWIG_InitializeModule: Cast List ******\n");
3634
for (i = 0; i < swig_module.size; ++i) {
3636
swig_cast_info *cast = swig_module.cast_initial[i];
3637
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3638
while (cast->type) {
3639
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
3643
printf("---- Total casts: %d\n",j);
3645
printf("**** SWIG_InitializeModule: Cast List ******\n");
3649
/* This function will propagate the clientdata field of type to
3650
* any new swig_type_info structures that have been added into the list
3651
* of equivalent types. It is like calling
3652
* SWIG_TypeClientData(type, clientdata) a second time.
3655
SWIG_PropagateClientData(void) {
3657
swig_cast_info *equiv;
3658
static int init_run = 0;
3660
if (init_run) return;
3663
for (i = 0; i < swig_module.size; i++) {
3664
if (swig_module.types[i]->clientdata) {
3665
equiv = swig_module.types[i]->cast;
3667
if (!equiv->converter) {
3668
if (equiv->type && !equiv->type->clientdata)
3669
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
3671
equiv = equiv->next;
3691
/* Python-specific SWIG API */
3692
#define SWIG_newvarlink() SWIG_Python_newvarlink()
3693
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
3694
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
3696
/* -----------------------------------------------------------------------------
3697
* global variable support code.
3698
* ----------------------------------------------------------------------------- */
3700
typedef struct swig_globalvar {
3701
char *name; /* Name of global variable */
3702
PyObject *(*get_attr)(void); /* Return the current value */
3703
int (*set_attr)(PyObject *); /* Set the value */
3704
struct swig_globalvar *next;
3707
typedef struct swig_varlinkobject {
3709
swig_globalvar *vars;
3710
} swig_varlinkobject;
3712
SWIGINTERN PyObject *
3713
swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
3714
#if PY_VERSION_HEX >= 0x03000000
3715
return PyUnicode_InternFromString("<Swig global variables>");
3717
return PyString_FromString("<Swig global variables>");
3721
SWIGINTERN PyObject *
3722
swig_varlink_str(swig_varlinkobject *v) {
3723
#if PY_VERSION_HEX >= 0x03000000
3724
PyObject *str = PyUnicode_InternFromString("(");
3727
swig_globalvar *var;
3728
for (var = v->vars; var; var=var->next) {
3729
tail = PyUnicode_FromString(var->name);
3730
joined = PyUnicode_Concat(str, tail);
3735
tail = PyUnicode_InternFromString(", ");
3736
joined = PyUnicode_Concat(str, tail);
3742
tail = PyUnicode_InternFromString(")");
3743
joined = PyUnicode_Concat(str, tail);
3748
PyObject *str = PyString_FromString("(");
3749
swig_globalvar *var;
3750
for (var = v->vars; var; var=var->next) {
3751
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
3752
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
3754
PyString_ConcatAndDel(&str,PyString_FromString(")"));
3760
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
3762
PyObject *str = swig_varlink_str(v);
3763
fprintf(fp,"Swig global variables ");
3764
fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
3765
SWIG_Python_str_DelForPy3(tmp);
3771
swig_varlink_dealloc(swig_varlinkobject *v) {
3772
swig_globalvar *var = v->vars;
3774
swig_globalvar *n = var->next;
3781
SWIGINTERN PyObject *
3782
swig_varlink_getattr(swig_varlinkobject *v, char *n) {
3783
PyObject *res = NULL;
3784
swig_globalvar *var = v->vars;
3786
if (strcmp(var->name,n) == 0) {
3787
res = (*var->get_attr)();
3792
if (res == NULL && !PyErr_Occurred()) {
3793
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
3799
swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
3801
swig_globalvar *var = v->vars;
3803
if (strcmp(var->name,n) == 0) {
3804
res = (*var->set_attr)(p);
3809
if (res == 1 && !PyErr_Occurred()) {
3810
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
3815
SWIGINTERN PyTypeObject*
3816
swig_varlink_type(void) {
3817
static char varlink__doc__[] = "Swig var link object";
3818
static PyTypeObject varlink_type;
3819
static int type_init = 0;
3821
const PyTypeObject tmp
3823
/* PyObject header changed in Python 3 */
3824
#if PY_VERSION_HEX >= 0x03000000
3825
PyVarObject_HEAD_INIT(&PyType_Type, 0)
3827
PyObject_HEAD_INIT(NULL)
3828
0, /* Number of items in variable part (ob_size) */
3830
(char *)"swigvarlink", /* Type name (tp_name) */
3831
sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
3832
0, /* Itemsize (tp_itemsize) */
3833
(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
3834
(printfunc) swig_varlink_print, /* Print (tp_print) */
3835
(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
3836
(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
3838
(reprfunc) swig_varlink_repr, /* tp_repr */
3839
0, /* tp_as_number */
3840
0, /* tp_as_sequence */
3841
0, /* tp_as_mapping */
3844
(reprfunc) swig_varlink_str, /* tp_str */
3845
0, /* tp_getattro */
3846
0, /* tp_setattro */
3847
0, /* tp_as_buffer */
3849
varlink__doc__, /* tp_doc */
3850
0, /* tp_traverse */
3852
0, /* tp_richcompare */
3853
0, /* tp_weaklistoffset */
3854
#if PY_VERSION_HEX >= 0x02020000
3855
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
3857
#if PY_VERSION_HEX >= 0x02030000
3861
0,0,0,0 /* tp_alloc -> tp_next */
3865
/* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
3866
#if PY_VERSION_HEX < 0x03000000
3867
varlink_type.ob_type = &PyType_Type;
3871
return &varlink_type;
3874
/* Create a variable linking object for use later */
3875
SWIGINTERN PyObject *
3876
SWIG_Python_newvarlink(void) {
3877
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
3881
return ((PyObject*) result);
3885
SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
3886
swig_varlinkobject *v = (swig_varlinkobject *) p;
3887
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
3889
size_t size = strlen(name)+1;
3890
gv->name = (char *)malloc(size);
3892
strncpy(gv->name,name,size);
3893
gv->get_attr = get_attr;
3894
gv->set_attr = set_attr;
3901
SWIGINTERN PyObject *
3902
SWIG_globals(void) {
3903
static PyObject *_SWIG_globals = 0;
3904
if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
3905
return _SWIG_globals;
3908
/* -----------------------------------------------------------------------------
3909
* constants/methods manipulation
3910
* ----------------------------------------------------------------------------- */
3912
/* Install Constants */
3914
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
3917
for (i = 0; constants[i].type; ++i) {
3918
switch(constants[i].type) {
3919
case SWIG_PY_POINTER:
3920
obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
3922
case SWIG_PY_BINARY:
3923
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
3930
PyDict_SetItemString(d, constants[i].name, obj);
3936
/* -----------------------------------------------------------------------------*/
3937
/* Fix SwigMethods to carry the callback ptrs when needed */
3938
/* -----------------------------------------------------------------------------*/
3941
SWIG_Python_FixMethods(PyMethodDef *methods,
3942
swig_const_info *const_table,
3943
swig_type_info **types,
3944
swig_type_info **types_initial) {
3946
for (i = 0; methods[i].ml_name; ++i) {
3947
const char *c = methods[i].ml_doc;
3948
if (c && (c = strstr(c, "swig_ptr: "))) {
3950
swig_const_info *ci = 0;
3951
const char *name = c + 10;
3952
for (j = 0; const_table[j].type; ++j) {
3953
if (strncmp(const_table[j].name, name,
3954
strlen(const_table[j].name)) == 0) {
3955
ci = &(const_table[j]);
3960
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
3962
size_t shift = (ci->ptype) - types;
3963
swig_type_info *ty = types_initial[shift];
3964
size_t ldoc = (c - methods[i].ml_doc);
3965
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
3966
char *ndoc = (char*)malloc(ldoc + lptr + 10);
3969
strncpy(buff, methods[i].ml_doc, ldoc);
3971
strncpy(buff, "swig_ptr: ", 10);
3973
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
3974
methods[i].ml_doc = ndoc;
3986
/* -----------------------------------------------------------------------------*
3987
* Partial Init method
3988
* -----------------------------------------------------------------------------*/
3995
#if PY_VERSION_HEX >= 0x03000000
4002
#if PY_VERSION_HEX >= 0x03000000
4003
static struct PyModuleDef SWIG_module = {
4004
PyModuleDef_HEAD_INIT,
4016
/* Fix SwigMethods to carry the callback ptrs when needed */
4017
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
4019
#if PY_VERSION_HEX >= 0x03000000
4020
m = PyModule_Create(&SWIG_module);
4022
m = Py_InitModule((char *) SWIG_name, SwigMethods);
4024
d = PyModule_GetDict(m);
4026
SWIG_InitializeModule(0);
4027
SWIG_InstallConstants(d,swig_const_table);
4033
#if PY_VERSION_HEX >= 0x03000000
added
removed
scipy/sparse/sparsetools/csgraph_wrap.cxx
