1
/* ----------------------------------------------------------------------------
2
* This file was automatically generated by SWIG (http://www.swig.org).
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
* ----------------------------------------------------------------------------- */
11
/* -----------------------------------------------------------------------------
12
* This section contains generic SWIG labels for method/variable
13
* declarations/attributes, and other compiler dependent labels.
14
* ----------------------------------------------------------------------------- */
16
/* template workaround for compilers that cannot correctly implement the C++ standard */
17
#ifndef SWIGTEMPLATEDISAMBIGUATOR
18
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
19
# define SWIGTEMPLATEDISAMBIGUATOR template
20
# elif defined(__HP_aCC)
21
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
22
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
23
# define SWIGTEMPLATEDISAMBIGUATOR template
25
# define SWIGTEMPLATEDISAMBIGUATOR
29
/* inline attribute */
31
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
32
# define SWIGINLINE inline
38
/* attribute recognised by some compilers to avoid 'unused' warnings */
40
# if defined(__GNUC__)
41
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
42
# define SWIGUNUSED __attribute__ ((__unused__))
47
# define SWIGUNUSED __attribute__ ((__unused__))
53
#ifndef SWIG_MSC_UNSUPPRESS_4505
54
# if defined(_MSC_VER)
55
# pragma warning(disable : 4505) /* unreferenced local function has been removed */
59
#ifndef SWIGUNUSEDPARM
61
# define SWIGUNUSEDPARM(p)
63
# define SWIGUNUSEDPARM(p) p SWIGUNUSED
67
/* internal SWIG method */
69
# define SWIGINTERN static SWIGUNUSED
72
/* internal inline SWIG method */
73
#ifndef SWIGINTERNINLINE
74
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
77
/* exporting methods */
78
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
79
# ifndef GCC_HASCLASSVISIBILITY
80
# define GCC_HASCLASSVISIBILITY
85
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
86
# if defined(STATIC_LINKED)
89
# define SWIGEXPORT __declspec(dllexport)
92
# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
93
# define SWIGEXPORT __attribute__ ((visibility("default")))
100
/* calling conventions for Windows */
102
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
103
# define SWIGSTDCALL __stdcall
109
/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
110
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
111
# define _CRT_SECURE_NO_DEPRECATE
114
/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
115
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
116
# define _SCL_SECURE_NO_DEPRECATE
120
#define SWIG_UnknownError -1
121
#define SWIG_IOError -2
122
#define SWIG_RuntimeError -3
123
#define SWIG_IndexError -4
124
#define SWIG_TypeError -5
125
#define SWIG_DivisionByZero -6
126
#define SWIG_OverflowError -7
127
#define SWIG_SyntaxError -8
128
#define SWIG_ValueError -9
129
#define SWIG_SystemError -10
130
#define SWIG_AttributeError -11
131
#define SWIG_MemoryError -12
132
#define SWIG_NullReferenceError -13
136
#define SWIG_UnknownError -1
137
#define SWIG_IOError -2
138
#define SWIG_RuntimeError -3
139
#define SWIG_IndexError -4
140
#define SWIG_TypeError -5
141
#define SWIG_DivisionByZero -6
142
#define SWIG_OverflowError -7
143
#define SWIG_SyntaxError -8
144
#define SWIG_ValueError -9
145
#define SWIG_SystemError -10
146
#define SWIG_AttributeError -11
147
#define SWIG_MemoryError -12
148
#define SWIG_NullReferenceError -13
151
/* -----------------------------------------------------------------------------
154
* This file contains generic CAPI 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 is strictly necessary, ie, if you have problems
177
with your compiler or so.
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 and 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 swig versions, you usually write code as:
213
if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
219
Now you can be more explicit as:
221
int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
222
if (SWIG_IsOK(res)) {
228
that seems to be the same, 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
requires also to SWIG_ConvertPtr to return new result values, 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()
282
#define SWIG_ERROR (-1)
283
#define SWIG_IsOK(r) (r >= 0)
284
#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
286
/* The CastRankLimit says how many bits are used for the cast rank */
287
#define SWIG_CASTRANKLIMIT (1 << 8)
288
/* The NewMask denotes the object was created (using new/malloc) */
289
#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
290
/* The TmpMask is for in/out typemaps that use temporal objects */
291
#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
292
/* Simple returning values */
293
#define SWIG_BADOBJ (SWIG_ERROR)
294
#define SWIG_OLDOBJ (SWIG_OK)
295
#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
296
#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
297
/* Check, add and del mask methods */
298
#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
299
#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
300
#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
301
#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
302
#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
303
#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
307
#if defined(SWIG_CASTRANK_MODE)
308
# ifndef SWIG_TypeRank
309
# define SWIG_TypeRank unsigned long
311
# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
312
# define SWIG_MAXCASTRANK (2)
314
# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
315
# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
316
SWIGINTERNINLINE int SWIG_AddCast(int r) {
317
return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
319
SWIGINTERNINLINE int SWIG_CheckState(int r) {
320
return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
322
#else /* no cast-rank mode */
323
# define SWIG_AddCast
324
# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
336
typedef void *(*swig_converter_func)(void *, int *);
337
typedef struct swig_type_info *(*swig_dycast_func)(void **);
339
/* Structure to store information on one type */
340
typedef struct swig_type_info {
341
const char *name; /* mangled name of this type */
342
const char *str; /* human readable name of this type */
343
swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
344
struct swig_cast_info *cast; /* linked list of types that can cast into this type */
345
void *clientdata; /* language specific type data */
346
int owndata; /* flag if the structure owns the clientdata */
349
/* Structure to store a type and conversion function used for casting */
350
typedef struct swig_cast_info {
351
swig_type_info *type; /* pointer to type that is equivalent to this type */
352
swig_converter_func converter; /* function to cast the void pointers */
353
struct swig_cast_info *next; /* pointer to next cast in linked list */
354
struct swig_cast_info *prev; /* pointer to the previous cast */
357
/* Structure used to store module information
358
* Each module generates one structure like this, and the runtime collects
359
* all of these structures and stores them in a circularly linked list.*/
360
typedef struct swig_module_info {
361
swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
362
size_t size; /* Number of types in this module */
363
struct swig_module_info *next; /* Pointer to next element in circularly linked list */
364
swig_type_info **type_initial; /* Array of initially generated type structures */
365
swig_cast_info **cast_initial; /* Array of initially generated casting structures */
366
void *clientdata; /* Language specific module data */
370
Compare two type names skipping the space characters, therefore
371
"char*" == "char *" and "Class<int>" == "Class<int >", etc.
373
Return 0 when the two name types are equivalent, as in
374
strncmp, but skipping ' '.
377
SWIG_TypeNameComp(const char *f1, const char *l1,
378
const char *f2, const char *l2) {
379
for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
380
while ((*f1 == ' ') && (f1 != l1)) ++f1;
381
while ((*f2 == ' ') && (f2 != l2)) ++f2;
382
if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
384
return (int)((l1 - f1) - (l2 - f2));
388
Check type equivalence in a name list like <name1>|<name2>|...
389
Return 0 if not equal, 1 if equal
392
SWIG_TypeEquiv(const char *nb, const char *tb) {
394
const char* te = tb + strlen(tb);
396
while (!equiv && *ne) {
397
for (nb = ne; *ne; ++ne) {
398
if (*ne == '|') break;
400
equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
407
Check type equivalence in a name list like <name1>|<name2>|...
408
Return 0 if equal, -1 if nb < tb, 1 if nb > tb
411
SWIG_TypeCompare(const char *nb, const char *tb) {
413
const char* te = tb + strlen(tb);
415
while (!equiv && *ne) {
416
for (nb = ne; *ne; ++ne) {
417
if (*ne == '|') break;
419
equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
426
/* think of this as a c++ template<> or a scheme macro */
427
#define SWIG_TypeCheck_Template(comparison, ty) \
429
swig_cast_info *iter = ty->cast; \
432
if (iter == ty->cast) return iter; \
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; \
451
SWIGRUNTIME swig_cast_info *
452
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
453
SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
456
/* Same as previous function, except strcmp is replaced with a pointer comparison */
457
SWIGRUNTIME swig_cast_info *
458
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
459
SWIG_TypeCheck_Template(iter->type == from, into);
463
Cast a pointer up an inheritance hierarchy
465
SWIGRUNTIMEINLINE void *
466
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
467
return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
471
Dynamic pointer casting. Down an inheritance hierarchy
473
SWIGRUNTIME swig_type_info *
474
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
475
swig_type_info *lastty = ty;
476
if (!ty || !ty->dcast) return ty;
477
while (ty && (ty->dcast)) {
478
ty = (*ty->dcast)(ptr);
485
Return the name associated with this type
487
SWIGRUNTIMEINLINE const char *
488
SWIG_TypeName(const swig_type_info *ty) {
493
Return the pretty name associated with this type,
494
that is an unmangled type name in a form presentable to the user.
496
SWIGRUNTIME const char *
497
SWIG_TypePrettyName(const swig_type_info *type) {
498
/* The "str" field contains the equivalent pretty names of the
499
type, separated by vertical-bar characters. We choose
500
to print the last name, as it is often (?) the most
502
if (!type) return NULL;
503
if (type->str != NULL) {
504
const char *last_name = type->str;
506
for (s = type->str; *s; s++)
507
if (*s == '|') last_name = s+1;
515
Set the clientdata field for a type
518
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
519
swig_cast_info *cast = ti->cast;
520
/* if (ti->clientdata == clientdata) return; */
521
ti->clientdata = clientdata;
524
if (!cast->converter) {
525
swig_type_info *tc = cast->type;
526
if (!tc->clientdata) {
527
SWIG_TypeClientData(tc, clientdata);
534
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
535
SWIG_TypeClientData(ti, clientdata);
540
Search for a swig_type_info structure only by mangled name
541
Search is a O(log #types)
543
We start searching at module start, and finish searching when start == end.
544
Note: if start == end at the beginning of the function, we go all the way around
547
SWIGRUNTIME swig_type_info *
548
SWIG_MangledTypeQueryModule(swig_module_info *start,
549
swig_module_info *end,
551
swig_module_info *iter = start;
554
register size_t l = 0;
555
register size_t r = iter->size - 1;
557
/* since l+r >= 0, we can (>> 1) instead (/ 2) */
558
register size_t i = (l + r) >> 1;
559
const char *iname = iter->types[i]->name;
561
register int compare = strcmp(name, iname);
563
return iter->types[i];
564
} else if (compare < 0) {
570
} else if (compare > 0) {
574
break; /* should never happen */
579
} while (iter != end);
584
Search for a swig_type_info structure for either a mangled name or a human readable name.
585
It first searches the mangled names of the types, which is a O(log #types)
586
If a type is not found it then searches the human readable names, which is O(#types).
588
We start searching at module start, and finish searching when start == end.
589
Note: if start == end at the beginning of the function, we go all the way around
592
SWIGRUNTIME swig_type_info *
593
SWIG_TypeQueryModule(swig_module_info *start,
594
swig_module_info *end,
596
/* STEP 1: Search the name field using binary search */
597
swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
601
/* STEP 2: If the type hasn't been found, do a complete search
602
of the str field (the human readable name) */
603
swig_module_info *iter = start;
605
register size_t i = 0;
606
for (; i < iter->size; ++i) {
607
if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
608
return iter->types[i];
611
} while (iter != end);
614
/* neither found a match */
619
Pack binary data into a string
622
SWIG_PackData(char *c, void *ptr, size_t sz) {
623
static const char hex[17] = "0123456789abcdef";
624
register const unsigned char *u = (unsigned char *) ptr;
625
register const unsigned char *eu = u + sz;
626
for (; u != eu; ++u) {
627
register unsigned char uu = *u;
628
*(c++) = hex[(uu & 0xf0) >> 4];
629
*(c++) = hex[uu & 0xf];
635
Unpack binary data from a string
637
SWIGRUNTIME const char *
638
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
639
register unsigned char *u = (unsigned char *) ptr;
640
register const unsigned char *eu = u + sz;
641
for (; u != eu; ++u) {
642
register char d = *(c++);
643
register unsigned char uu;
644
if ((d >= '0') && (d <= '9'))
645
uu = ((d - '0') << 4);
646
else if ((d >= 'a') && (d <= 'f'))
647
uu = ((d - ('a'-10)) << 4);
651
if ((d >= '0') && (d <= '9'))
653
else if ((d >= 'a') && (d <= 'f'))
654
uu |= (d - ('a'-10));
663
Pack 'void *' into a string buffer.
666
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
668
if ((2*sizeof(void *) + 2) > bsz) return 0;
670
r = SWIG_PackData(r,&ptr,sizeof(void *));
671
if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
676
SWIGRUNTIME const char *
677
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
679
if (strcmp(c,"NULL") == 0) {
686
return SWIG_UnpackData(++c,ptr,sizeof(void *));
690
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
692
size_t lname = (name ? strlen(name) : 0);
693
if ((2*sz + 2 + lname) > bsz) return 0;
695
r = SWIG_PackData(r,ptr,sz);
697
strncpy(r,name,lname+1);
704
SWIGRUNTIME const char *
705
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
707
if (strcmp(c,"NULL") == 0) {
714
return SWIG_UnpackData(++c,ptr,sz);
721
/* Add PyOS_snprintf for old Pythons */
722
#if PY_VERSION_HEX < 0x02020000
723
# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
724
# define PyOS_snprintf _snprintf
726
# define PyOS_snprintf snprintf
730
/* A crude PyString_FromFormat implementation for old Pythons */
731
#if PY_VERSION_HEX < 0x02020000
733
#ifndef SWIG_PYBUFFER_SIZE
734
# define SWIG_PYBUFFER_SIZE 1024
738
PyString_FromFormat(const char *fmt, ...) {
740
char buf[SWIG_PYBUFFER_SIZE * 2];
743
res = vsnprintf(buf, sizeof(buf), fmt, ap);
745
return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
749
/* Add PyObject_Del for old Pythons */
750
#if PY_VERSION_HEX < 0x01060000
751
# define PyObject_Del(op) PyMem_DEL((op))
754
# define PyObject_DEL PyObject_Del
757
/* A crude PyExc_StopIteration exception for old Pythons */
758
#if PY_VERSION_HEX < 0x02020000
759
# ifndef PyExc_StopIteration
760
# define PyExc_StopIteration PyExc_RuntimeError
762
# ifndef PyObject_GenericGetAttr
763
# define PyObject_GenericGetAttr 0
766
/* Py_NotImplemented is defined in 2.1 and up. */
767
#if PY_VERSION_HEX < 0x02010000
768
# ifndef Py_NotImplemented
769
# define Py_NotImplemented PyExc_RuntimeError
774
/* A crude PyString_AsStringAndSize implementation for old Pythons */
775
#if PY_VERSION_HEX < 0x02010000
776
# ifndef PyString_AsStringAndSize
777
# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
781
/* PySequence_Size for old Pythons */
782
#if PY_VERSION_HEX < 0x02000000
783
# ifndef PySequence_Size
784
# define PySequence_Size PySequence_Length
789
/* PyBool_FromLong for old Pythons */
790
#if PY_VERSION_HEX < 0x02030000
792
PyObject *PyBool_FromLong(long ok)
794
PyObject *result = ok ? Py_True : Py_False;
800
/* Py_ssize_t for old Pythons */
801
/* This code is as recommended by: */
802
/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
803
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
804
typedef int Py_ssize_t;
805
# define PY_SSIZE_T_MAX INT_MAX
806
# define PY_SSIZE_T_MIN INT_MIN
808
/* -----------------------------------------------------------------------------
810
* ----------------------------------------------------------------------------- */
812
SWIGRUNTIME PyObject*
813
SWIG_Python_ErrorType(int code) {
816
case SWIG_MemoryError:
817
type = PyExc_MemoryError;
820
type = PyExc_IOError;
822
case SWIG_RuntimeError:
823
type = PyExc_RuntimeError;
825
case SWIG_IndexError:
826
type = PyExc_IndexError;
829
type = PyExc_TypeError;
831
case SWIG_DivisionByZero:
832
type = PyExc_ZeroDivisionError;
834
case SWIG_OverflowError:
835
type = PyExc_OverflowError;
837
case SWIG_SyntaxError:
838
type = PyExc_SyntaxError;
840
case SWIG_ValueError:
841
type = PyExc_ValueError;
843
case SWIG_SystemError:
844
type = PyExc_SystemError;
846
case SWIG_AttributeError:
847
type = PyExc_AttributeError;
850
type = PyExc_RuntimeError;
857
SWIG_Python_AddErrorMsg(const char* mesg)
861
PyObject *traceback = 0;
863
if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
865
PyObject *old_str = PyObject_Str(value);
868
PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
872
PyErr_SetString(PyExc_RuntimeError, mesg);
877
#if defined(SWIG_PYTHON_NO_THREADS)
878
# if defined(SWIG_PYTHON_THREADS)
879
# undef SWIG_PYTHON_THREADS
882
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
883
# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
884
# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
885
# define SWIG_PYTHON_USE_GIL
888
# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
889
# ifndef SWIG_PYTHON_INITIALIZE_THREADS
890
# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
892
# ifdef __cplusplus /* C++ code */
893
class SWIG_Python_Thread_Block {
895
PyGILState_STATE state;
897
void end() { if (status) { PyGILState_Release(state); status = false;} }
898
SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
899
~SWIG_Python_Thread_Block() { end(); }
901
class SWIG_Python_Thread_Allow {
905
void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
906
SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
907
~SWIG_Python_Thread_Allow() { end(); }
909
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
910
# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
911
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
912
# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
914
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
915
# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
916
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
917
# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
919
# else /* Old thread way, not implemented, user must provide it */
920
# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
921
# define SWIG_PYTHON_INITIALIZE_THREADS
923
# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
924
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
926
# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
927
# define SWIG_PYTHON_THREAD_END_BLOCK
929
# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
930
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
932
# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
933
# define SWIG_PYTHON_THREAD_END_ALLOW
936
#else /* No thread support */
937
# define SWIG_PYTHON_INITIALIZE_THREADS
938
# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
939
# define SWIG_PYTHON_THREAD_END_BLOCK
940
# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
941
# define SWIG_PYTHON_THREAD_END_ALLOW
943
/* -----------------------------------------------------------------------------
944
* Python API portion that goes into the runtime
945
* ----------------------------------------------------------------------------- */
954
/* -----------------------------------------------------------------------------
955
* Constant declarations
956
* ----------------------------------------------------------------------------- */
959
#define SWIG_PY_POINTER 4
960
#define SWIG_PY_BINARY 5
962
/* Constant information structure */
963
typedef struct swig_const_info {
969
swig_type_info **ptype;
979
/* -----------------------------------------------------------------------------
980
* See the LICENSE file for information on copyright, usage and redistribution
981
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
985
* This file contains the runtime support for Python modules
986
* and includes code for managing global variables and pointer
989
* ----------------------------------------------------------------------------- */
991
/* Common SWIG API */
993
/* for raw pointers */
994
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
995
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
996
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
997
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
998
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
999
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1000
#define swig_owntype int
1002
/* for raw packed data */
1003
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1004
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1006
/* for class or struct pointers */
1007
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1008
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1010
/* for C or C++ function pointers */
1011
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1012
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1014
/* for C++ member pointers, ie, member methods */
1015
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1016
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1021
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1022
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1023
#define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1025
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1026
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1027
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1028
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1029
#define SWIG_fail goto fail
1032
/* Runtime API implementation */
1034
/* Error manipulation */
1037
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1038
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1039
PyErr_SetObject(errtype, obj);
1041
SWIG_PYTHON_THREAD_END_BLOCK;
1045
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1046
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1047
PyErr_SetString(errtype, (char *) msg);
1048
SWIG_PYTHON_THREAD_END_BLOCK;
1051
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1053
/* Set a constant value */
1056
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1057
PyDict_SetItemString(d, (char*) name, obj);
1061
/* Append a value to the result obj */
1063
SWIGINTERN PyObject*
1064
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1065
#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1068
} else if (result == Py_None) {
1072
if (!PyList_Check(result)) {
1073
PyObject *o2 = result;
1074
result = PyList_New(1);
1075
PyList_SetItem(result, 0, o2);
1077
PyList_Append(result,obj);
1086
} else if (result == Py_None) {
1090
if (!PyTuple_Check(result)) {
1092
result = PyTuple_New(1);
1093
PyTuple_SET_ITEM(result, 0, o2);
1095
o3 = PyTuple_New(1);
1096
PyTuple_SET_ITEM(o3, 0, obj);
1098
result = PySequence_Concat(o2, o3);
1106
/* Unpack the argument tuple */
1109
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1115
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1116
name, (min == max ? "" : "at least "), (int)min);
1120
if (!PyTuple_Check(args)) {
1121
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1124
register Py_ssize_t l = PyTuple_GET_SIZE(args);
1126
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1127
name, (min == max ? "" : "at least "), (int)min, (int)l);
1129
} else if (l > max) {
1130
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1131
name, (min == max ? "" : "at most "), (int)max, (int)l);
1135
for (i = 0; i < l; ++i) {
1136
objs[i] = PyTuple_GET_ITEM(args, i);
1138
for (; l < max; ++l) {
1146
/* A functor is a function object with one single object argument */
1147
#if PY_VERSION_HEX >= 0x02020000
1148
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1150
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1154
Helper for static pointer initialization for both C and C++ code, for example
1155
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1158
#define SWIG_STATIC_POINTER(var) var
1160
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1163
/* -----------------------------------------------------------------------------
1164
* Pointer declarations
1165
* ----------------------------------------------------------------------------- */
1167
/* Flags for new pointer objects */
1168
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1169
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1171
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1180
/* How to access Py_None */
1181
#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1182
# ifndef SWIG_PYTHON_NO_BUILD_NONE
1183
# ifndef SWIG_PYTHON_BUILD_NONE
1184
# define SWIG_PYTHON_BUILD_NONE
1189
#ifdef SWIG_PYTHON_BUILD_NONE
1192
# define Py_None SWIG_Py_None()
1194
SWIGRUNTIMEINLINE PyObject *
1197
PyObject *none = Py_BuildValue((char*)"");
1201
SWIGRUNTIME PyObject *
1204
static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1209
/* The python void return value */
1211
SWIGRUNTIMEINLINE PyObject *
1214
PyObject *none = Py_None;
1219
/* PySwigClientData */
1230
SWIGRUNTIMEINLINE int
1231
SWIG_Python_CheckImplicit(swig_type_info *ty)
1233
PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1234
return data ? data->implicitconv : 0;
1237
SWIGRUNTIMEINLINE PyObject *
1238
SWIG_Python_ExceptionType(swig_type_info *desc) {
1239
PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1240
PyObject *klass = data ? data->klass : 0;
1241
return (klass ? klass : PyExc_RuntimeError);
1245
SWIGRUNTIME PySwigClientData *
1246
PySwigClientData_New(PyObject* obj)
1251
PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1252
/* the klass element */
1254
Py_INCREF(data->klass);
1255
/* the newraw method and newargs arguments used to create a new raw instance */
1256
if (PyClass_Check(obj)) {
1258
data->newargs = obj;
1261
#if (PY_VERSION_HEX < 0x02020000)
1264
data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1267
Py_INCREF(data->newraw);
1268
data->newargs = PyTuple_New(1);
1269
PyTuple_SetItem(data->newargs, 0, obj);
1271
data->newargs = obj;
1273
Py_INCREF(data->newargs);
1275
/* the destroy method, aka as the C++ delete method */
1276
data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1277
if (PyErr_Occurred()) {
1281
if (data->destroy) {
1283
Py_INCREF(data->destroy);
1284
flags = PyCFunction_GET_FLAGS(data->destroy);
1286
data->delargs = !(flags & (METH_O));
1293
data->implicitconv = 0;
1299
PySwigClientData_Del(PySwigClientData* data)
1301
Py_XDECREF(data->newraw);
1302
Py_XDECREF(data->newargs);
1303
Py_XDECREF(data->destroy);
1306
/* =============== PySwigObject =====================*/
1316
SWIGRUNTIME PyObject *
1317
PySwigObject_long(PySwigObject *v)
1319
return PyLong_FromVoidPtr(v->ptr);
1322
SWIGRUNTIME PyObject *
1323
PySwigObject_format(const char* fmt, PySwigObject *v)
1325
PyObject *res = NULL;
1326
PyObject *args = PyTuple_New(1);
1328
if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1329
PyObject *ofmt = PyString_FromString(fmt);
1331
res = PyString_Format(ofmt,args);
1340
SWIGRUNTIME PyObject *
1341
PySwigObject_oct(PySwigObject *v)
1343
return PySwigObject_format("%o",v);
1346
SWIGRUNTIME PyObject *
1347
PySwigObject_hex(PySwigObject *v)
1349
return PySwigObject_format("%x",v);
1352
SWIGRUNTIME PyObject *
1354
PySwigObject_repr(PySwigObject *v)
1356
PySwigObject_repr(PySwigObject *v, PyObject *args)
1359
const char *name = SWIG_TypePrettyName(v->ty);
1360
PyObject *hex = PySwigObject_hex(v);
1361
PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1365
PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1367
PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1369
PyString_ConcatAndDel(&repr,nrep);
1375
PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1378
PyObject *repr = PySwigObject_repr(v);
1380
PyObject *repr = PySwigObject_repr(v, NULL);
1383
fputs(PyString_AsString(repr), fp);
1391
SWIGRUNTIME PyObject *
1392
PySwigObject_str(PySwigObject *v)
1394
char result[SWIG_BUFFER_SIZE];
1395
return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1396
PyString_FromString(result) : 0;
1400
PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1404
return (i < j) ? -1 : ((i > j) ? 1 : 0);
1407
SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1409
SWIGRUNTIME PyTypeObject*
1410
PySwigObject_type(void) {
1411
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1415
SWIGRUNTIMEINLINE int
1416
PySwigObject_Check(PyObject *op) {
1417
return ((op)->ob_type == PySwigObject_type())
1418
|| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1421
SWIGRUNTIME PyObject *
1422
PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1425
PySwigObject_dealloc(PyObject *v)
1427
PySwigObject *sobj = (PySwigObject *) v;
1428
PyObject *next = sobj->next;
1429
if (sobj->own == SWIG_POINTER_OWN) {
1430
swig_type_info *ty = sobj->ty;
1431
PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1432
PyObject *destroy = data ? data->destroy : 0;
1434
/* destroy is always a VARARGS method */
1436
if (data->delargs) {
1437
/* we need to create a temporal object to carry the destroy operation */
1438
PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1439
res = SWIG_Python_CallFunctor(destroy, tmp);
1442
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1443
PyObject *mself = PyCFunction_GET_SELF(destroy);
1444
res = ((*meth)(mself, v));
1448
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1450
const char *name = SWIG_TypePrettyName(ty);
1451
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1459
SWIGRUNTIME PyObject*
1460
PySwigObject_append(PyObject* v, PyObject* next)
1462
PySwigObject *sobj = (PySwigObject *) v;
1465
if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1468
if (!PySwigObject_Check(next)) {
1473
return SWIG_Py_Void();
1476
SWIGRUNTIME PyObject*
1478
PySwigObject_next(PyObject* v)
1480
PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1483
PySwigObject *sobj = (PySwigObject *) v;
1485
Py_INCREF(sobj->next);
1488
return SWIG_Py_Void();
1492
SWIGINTERN PyObject*
1494
PySwigObject_disown(PyObject *v)
1496
PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1499
PySwigObject *sobj = (PySwigObject *)v;
1501
return SWIG_Py_Void();
1504
SWIGINTERN PyObject*
1506
PySwigObject_acquire(PyObject *v)
1508
PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1511
PySwigObject *sobj = (PySwigObject *)v;
1512
sobj->own = SWIG_POINTER_OWN;
1513
return SWIG_Py_Void();
1516
SWIGINTERN PyObject*
1517
PySwigObject_own(PyObject *v, PyObject *args)
1520
#if (PY_VERSION_HEX < 0x02020000)
1521
if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1523
if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1530
PySwigObject *sobj = (PySwigObject *)v;
1531
PyObject *obj = PyBool_FromLong(sobj->own);
1534
if (PyObject_IsTrue(val)) {
1535
PySwigObject_acquire(v);
1537
PySwigObject_disown(v);
1540
if (PyObject_IsTrue(val)) {
1541
PySwigObject_acquire(v,args);
1543
PySwigObject_disown(v,args);
1553
swigobject_methods[] = {
1554
{(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1555
{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1556
{(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1557
{(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1558
{(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1559
{(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1564
swigobject_methods[] = {
1565
{(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1566
{(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1567
{(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1568
{(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1569
{(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1570
{(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1575
#if PY_VERSION_HEX < 0x02020000
1576
SWIGINTERN PyObject *
1577
PySwigObject_getattr(PySwigObject *sobj,char *name)
1579
return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1583
SWIGRUNTIME PyTypeObject*
1584
_PySwigObject_type(void) {
1585
static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1587
static PyNumberMethods PySwigObject_as_number = {
1588
(binaryfunc)0, /*nb_add*/
1589
(binaryfunc)0, /*nb_subtract*/
1590
(binaryfunc)0, /*nb_multiply*/
1591
(binaryfunc)0, /*nb_divide*/
1592
(binaryfunc)0, /*nb_remainder*/
1593
(binaryfunc)0, /*nb_divmod*/
1594
(ternaryfunc)0,/*nb_power*/
1595
(unaryfunc)0, /*nb_negative*/
1596
(unaryfunc)0, /*nb_positive*/
1597
(unaryfunc)0, /*nb_absolute*/
1598
(inquiry)0, /*nb_nonzero*/
1605
(coercion)0, /*nb_coerce*/
1606
(unaryfunc)PySwigObject_long, /*nb_int*/
1607
(unaryfunc)PySwigObject_long, /*nb_long*/
1608
(unaryfunc)0, /*nb_float*/
1609
(unaryfunc)PySwigObject_oct, /*nb_oct*/
1610
(unaryfunc)PySwigObject_hex, /*nb_hex*/
1611
#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1612
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1613
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1614
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1615
#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1616
0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1620
static PyTypeObject pyswigobject_type;
1621
static int type_init = 0;
1623
const PyTypeObject tmp
1625
PyObject_HEAD_INIT(NULL)
1627
(char *)"PySwigObject", /* tp_name */
1628
sizeof(PySwigObject), /* tp_basicsize */
1629
0, /* tp_itemsize */
1630
(destructor)PySwigObject_dealloc, /* tp_dealloc */
1631
(printfunc)PySwigObject_print, /* tp_print */
1632
#if PY_VERSION_HEX < 0x02020000
1633
(getattrfunc)PySwigObject_getattr, /* tp_getattr */
1635
(getattrfunc)0, /* tp_getattr */
1637
(setattrfunc)0, /* tp_setattr */
1638
(cmpfunc)PySwigObject_compare, /* tp_compare */
1639
(reprfunc)PySwigObject_repr, /* tp_repr */
1640
&PySwigObject_as_number, /* tp_as_number */
1641
0, /* tp_as_sequence */
1642
0, /* tp_as_mapping */
1643
(hashfunc)0, /* tp_hash */
1644
(ternaryfunc)0, /* tp_call */
1645
(reprfunc)PySwigObject_str, /* tp_str */
1646
PyObject_GenericGetAttr, /* tp_getattro */
1647
0, /* tp_setattro */
1648
0, /* tp_as_buffer */
1649
Py_TPFLAGS_DEFAULT, /* tp_flags */
1650
swigobject_doc, /* tp_doc */
1651
0, /* tp_traverse */
1653
0, /* tp_richcompare */
1654
0, /* tp_weaklistoffset */
1655
#if PY_VERSION_HEX >= 0x02020000
1657
0, /* tp_iternext */
1658
swigobject_methods, /* tp_methods */
1663
0, /* tp_descr_get */
1664
0, /* tp_descr_set */
1665
0, /* tp_dictoffset */
1674
0, /* tp_subclasses */
1675
0, /* tp_weaklist */
1677
#if PY_VERSION_HEX >= 0x02030000
1681
0,0,0,0 /* tp_alloc -> tp_next */
1684
pyswigobject_type = tmp;
1685
pyswigobject_type.ob_type = &PyType_Type;
1688
return &pyswigobject_type;
1691
SWIGRUNTIME PyObject *
1692
PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1694
PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1701
return (PyObject *)sobj;
1704
/* -----------------------------------------------------------------------------
1705
* Implements a simple Swig Packed type, and use it instead of string
1706
* ----------------------------------------------------------------------------- */
1716
PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1718
char result[SWIG_BUFFER_SIZE];
1719
fputs("<Swig Packed ", fp);
1720
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1724
fputs(v->ty->name,fp);
1729
SWIGRUNTIME PyObject *
1730
PySwigPacked_repr(PySwigPacked *v)
1732
char result[SWIG_BUFFER_SIZE];
1733
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1734
return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1736
return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1740
SWIGRUNTIME PyObject *
1741
PySwigPacked_str(PySwigPacked *v)
1743
char result[SWIG_BUFFER_SIZE];
1744
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1745
return PyString_FromFormat("%s%s", result, v->ty->name);
1747
return PyString_FromString(v->ty->name);
1752
PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1756
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1757
return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1760
SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1762
SWIGRUNTIME PyTypeObject*
1763
PySwigPacked_type(void) {
1764
static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1768
SWIGRUNTIMEINLINE int
1769
PySwigPacked_Check(PyObject *op) {
1770
return ((op)->ob_type == _PySwigPacked_type())
1771
|| (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1775
PySwigPacked_dealloc(PyObject *v)
1777
if (PySwigPacked_Check(v)) {
1778
PySwigPacked *sobj = (PySwigPacked *) v;
1784
SWIGRUNTIME PyTypeObject*
1785
_PySwigPacked_type(void) {
1786
static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1787
static PyTypeObject pyswigpacked_type;
1788
static int type_init = 0;
1790
const PyTypeObject tmp
1792
PyObject_HEAD_INIT(NULL)
1794
(char *)"PySwigPacked", /* tp_name */
1795
sizeof(PySwigPacked), /* tp_basicsize */
1796
0, /* tp_itemsize */
1797
(destructor)PySwigPacked_dealloc, /* tp_dealloc */
1798
(printfunc)PySwigPacked_print, /* tp_print */
1799
(getattrfunc)0, /* tp_getattr */
1800
(setattrfunc)0, /* tp_setattr */
1801
(cmpfunc)PySwigPacked_compare, /* tp_compare */
1802
(reprfunc)PySwigPacked_repr, /* tp_repr */
1803
0, /* tp_as_number */
1804
0, /* tp_as_sequence */
1805
0, /* tp_as_mapping */
1806
(hashfunc)0, /* tp_hash */
1807
(ternaryfunc)0, /* tp_call */
1808
(reprfunc)PySwigPacked_str, /* tp_str */
1809
PyObject_GenericGetAttr, /* tp_getattro */
1810
0, /* tp_setattro */
1811
0, /* tp_as_buffer */
1812
Py_TPFLAGS_DEFAULT, /* tp_flags */
1813
swigpacked_doc, /* tp_doc */
1814
0, /* tp_traverse */
1816
0, /* tp_richcompare */
1817
0, /* tp_weaklistoffset */
1818
#if PY_VERSION_HEX >= 0x02020000
1820
0, /* tp_iternext */
1826
0, /* tp_descr_get */
1827
0, /* tp_descr_set */
1828
0, /* tp_dictoffset */
1837
0, /* tp_subclasses */
1838
0, /* tp_weaklist */
1840
#if PY_VERSION_HEX >= 0x02030000
1844
0,0,0,0 /* tp_alloc -> tp_next */
1847
pyswigpacked_type = tmp;
1848
pyswigpacked_type.ob_type = &PyType_Type;
1851
return &pyswigpacked_type;
1854
SWIGRUNTIME PyObject *
1855
PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1857
PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1859
void *pack = malloc(size);
1861
memcpy(pack, ptr, size);
1866
PyObject_DEL((PyObject *) sobj);
1870
return (PyObject *) sobj;
1873
SWIGRUNTIME swig_type_info *
1874
PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1876
if (PySwigPacked_Check(obj)) {
1877
PySwigPacked *sobj = (PySwigPacked *)obj;
1878
if (sobj->size != size) return 0;
1879
memcpy(ptr, sobj->pack, size);
1886
/* -----------------------------------------------------------------------------
1887
* pointers/data manipulation
1888
* ----------------------------------------------------------------------------- */
1890
SWIGRUNTIMEINLINE PyObject *
1893
return PyString_FromString("this");
1896
SWIGRUNTIME PyObject *
1899
static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1903
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1905
SWIGRUNTIME PySwigObject *
1906
SWIG_Python_GetSwigThis(PyObject *pyobj)
1908
if (PySwigObject_Check(pyobj)) {
1909
return (PySwigObject *) pyobj;
1912
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1913
if (PyInstance_Check(pyobj)) {
1914
obj = _PyInstance_Lookup(pyobj, SWIG_This());
1916
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1917
if (dictptr != NULL) {
1918
PyObject *dict = *dictptr;
1919
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1921
#ifdef PyWeakref_CheckProxy
1922
if (PyWeakref_CheckProxy(pyobj)) {
1923
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1924
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1927
obj = PyObject_GetAttr(pyobj,SWIG_This());
1931
if (PyErr_Occurred()) PyErr_Clear();
1937
obj = PyObject_GetAttr(pyobj,SWIG_This());
1941
if (PyErr_Occurred()) PyErr_Clear();
1945
if (obj && !PySwigObject_Check(obj)) {
1946
/* a PyObject is called 'this', try to get the 'real this'
1947
PySwigObject from it */
1948
return SWIG_Python_GetSwigThis(obj);
1950
return (PySwigObject *)obj;
1954
/* Acquire a pointer value */
1957
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1958
if (own == SWIG_POINTER_OWN) {
1959
PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1961
int oldown = sobj->own;
1969
/* Convert a pointer value */
1972
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1973
if (!obj) return SWIG_ERROR;
1974
if (obj == Py_None) {
1978
PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1982
void *vptr = sobj->ptr;
1984
swig_type_info *to = sobj->ty;
1986
/* no type cast needed */
1987
if (ptr) *ptr = vptr;
1990
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1992
sobj = (PySwigObject *)sobj->next;
1996
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
1997
if (newmemory == SWIG_CAST_NEW_MEMORY) {
2000
*own = *own | SWIG_CAST_NEW_MEMORY;
2007
if (ptr) *ptr = vptr;
2013
*own = *own | sobj->own;
2014
if (flags & SWIG_POINTER_DISOWN) {
2019
int res = SWIG_ERROR;
2020
if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2021
PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2022
if (data && !data->implicitconv) {
2023
PyObject *klass = data->klass;
2026
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2027
impconv = SWIG_Python_CallFunctor(klass, obj);
2028
data->implicitconv = 0;
2029
if (PyErr_Occurred()) {
2034
PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2037
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2038
if (SWIG_IsOK(res)) {
2041
/* transfer the ownership to 'ptr' */
2043
res = SWIG_AddCast(res);
2044
res = SWIG_AddNewMask(res);
2046
res = SWIG_AddCast(res);
2060
/* Convert a function ptr value */
2063
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2064
if (!PyCFunction_Check(obj)) {
2065
return SWIG_ConvertPtr(obj, ptr, ty, 0);
2069
/* here we get the method pointer for callbacks */
2070
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2071
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2073
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2074
if (!desc) return SWIG_ERROR;
2077
swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2080
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2081
assert(!newmemory); /* newmemory handling not yet implemented */
2092
/* Convert a packed value value */
2095
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2096
swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2097
if (!to) return SWIG_ERROR;
2100
/* check type cast? */
2101
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2102
if (!tc) return SWIG_ERROR;
2108
/* -----------------------------------------------------------------------------
2109
* Create a new pointer object
2110
* ----------------------------------------------------------------------------- */
2113
Create a new instance object, whitout calling __init__, and set the
2117
SWIGRUNTIME PyObject*
2118
SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2120
#if (PY_VERSION_HEX >= 0x02020000)
2122
PyObject *newraw = data->newraw;
2124
inst = PyObject_Call(newraw, data->newargs, NULL);
2126
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2127
PyObject **dictptr = _PyObject_GetDictPtr(inst);
2128
if (dictptr != NULL) {
2129
PyObject *dict = *dictptr;
2131
dict = PyDict_New();
2133
PyDict_SetItem(dict, SWIG_This(), swig_this);
2137
PyObject *key = SWIG_This();
2138
PyObject_SetAttr(inst, key, swig_this);
2142
PyObject *dict = PyDict_New();
2143
PyDict_SetItem(dict, SWIG_This(), swig_this);
2144
inst = PyInstance_NewRaw(data->newargs, dict);
2149
#if (PY_VERSION_HEX >= 0x02010000)
2151
PyObject *dict = PyDict_New();
2152
PyDict_SetItem(dict, SWIG_This(), swig_this);
2153
inst = PyInstance_NewRaw(data->newargs, dict);
2155
return (PyObject *) inst;
2157
PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2161
inst->in_class = (PyClassObject *)data->newargs;
2162
Py_INCREF(inst->in_class);
2163
inst->in_dict = PyDict_New();
2164
if (inst->in_dict == NULL) {
2168
#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2169
inst->in_weakreflist = NULL;
2171
#ifdef Py_TPFLAGS_GC
2172
PyObject_GC_Init(inst);
2174
PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2175
return (PyObject *) inst;
2181
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2184
#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2185
PyObject **dictptr = _PyObject_GetDictPtr(inst);
2186
if (dictptr != NULL) {
2189
dict = PyDict_New();
2192
PyDict_SetItem(dict, SWIG_This(), swig_this);
2196
dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2197
PyDict_SetItem(dict, SWIG_This(), swig_this);
2202
SWIGINTERN PyObject *
2203
SWIG_Python_InitShadowInstance(PyObject *args) {
2205
if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2208
PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2210
PySwigObject_append((PyObject*) sthis, obj[1]);
2212
SWIG_Python_SetSwigThis(obj[0], obj[1]);
2214
return SWIG_Py_Void();
2218
/* Create a new pointer object */
2220
SWIGRUNTIME PyObject *
2221
SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2223
return SWIG_Py_Void();
2225
int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2226
PyObject *robj = PySwigObject_New(ptr, type, own);
2227
PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2228
if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2229
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2239
/* Create a new packed object */
2241
SWIGRUNTIMEINLINE PyObject *
2242
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2243
return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2246
/* -----------------------------------------------------------------------------*
2248
* -----------------------------------------------------------------------------*/
2250
#ifdef SWIG_LINK_RUNTIME
2251
void *SWIG_ReturnGlobalTypeList(void *);
2254
SWIGRUNTIME swig_module_info *
2255
SWIG_Python_GetModule(void) {
2256
static void *type_pointer = (void *)0;
2257
/* first check if module already created */
2258
if (!type_pointer) {
2259
#ifdef SWIG_LINK_RUNTIME
2260
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2262
type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2263
(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2264
if (PyErr_Occurred()) {
2266
type_pointer = (void *)0;
2270
return (swig_module_info *) type_pointer;
2273
#if PY_MAJOR_VERSION < 2
2274
/* PyModule_AddObject function was introduced in Python 2.0. The following function
2275
is copied out of Python/modsupport.c in python version 2.3.4 */
2277
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2280
if (!PyModule_Check(m)) {
2281
PyErr_SetString(PyExc_TypeError,
2282
"PyModule_AddObject() needs module as first arg");
2286
PyErr_SetString(PyExc_TypeError,
2287
"PyModule_AddObject() needs non-NULL value");
2291
dict = PyModule_GetDict(m);
2293
/* Internal error -- modules must have a dict! */
2294
PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2295
PyModule_GetName(m));
2298
if (PyDict_SetItemString(dict, name, o))
2306
SWIG_Python_DestroyModule(void *vptr)
2308
swig_module_info *swig_module = (swig_module_info *) vptr;
2309
swig_type_info **types = swig_module->types;
2311
for (i =0; i < swig_module->size; ++i) {
2312
swig_type_info *ty = types[i];
2314
PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2315
if (data) PySwigClientData_Del(data);
2318
Py_DECREF(SWIG_This());
2322
SWIG_Python_SetModule(swig_module_info *swig_module) {
2323
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2325
PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2326
swig_empty_runtime_method_table);
2327
PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2328
if (pointer && module) {
2329
PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2331
Py_XDECREF(pointer);
2335
/* The python cached type query */
2336
SWIGRUNTIME PyObject *
2337
SWIG_Python_TypeCache(void) {
2338
static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2342
SWIGRUNTIME swig_type_info *
2343
SWIG_Python_TypeQuery(const char *type)
2345
PyObject *cache = SWIG_Python_TypeCache();
2346
PyObject *key = PyString_FromString(type);
2347
PyObject *obj = PyDict_GetItem(cache, key);
2348
swig_type_info *descriptor;
2350
descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2352
swig_module_info *swig_module = SWIG_Python_GetModule();
2353
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2355
obj = PyCObject_FromVoidPtr(descriptor, NULL);
2356
PyDict_SetItem(cache, key, obj);
2365
For backward compatibility only
2367
#define SWIG_POINTER_EXCEPTION 0
2368
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2369
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2372
SWIG_Python_AddErrMesg(const char* mesg, int infront)
2374
if (PyErr_Occurred()) {
2376
PyObject *value = 0;
2377
PyObject *traceback = 0;
2378
PyErr_Fetch(&type, &value, &traceback);
2380
PyObject *old_str = PyObject_Str(value);
2384
PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2386
PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2397
SWIG_Python_ArgFail(int argnum)
2399
if (PyErr_Occurred()) {
2400
/* add information about failing argument */
2402
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2403
return SWIG_Python_AddErrMesg(mesg, 1);
2409
SWIGRUNTIMEINLINE const char *
2410
PySwigObject_GetDesc(PyObject *self)
2412
PySwigObject *v = (PySwigObject *)self;
2413
swig_type_info *ty = v ? v->ty : 0;
2414
return ty ? ty->str : (char*)"";
2418
SWIG_Python_TypeError(const char *type, PyObject *obj)
2421
#if defined(SWIG_COBJECT_TYPES)
2422
if (obj && PySwigObject_Check(obj)) {
2423
const char *otype = (const char *) PySwigObject_GetDesc(obj);
2425
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2432
const char *otype = (obj ? obj->ob_type->tp_name : 0);
2434
PyObject *str = PyObject_Str(obj);
2435
const char *cstr = str ? PyString_AsString(str) : 0;
2437
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2440
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2447
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2449
PyErr_Format(PyExc_TypeError, "unexpected type is received");
2454
/* Convert a pointer value, signal an exception on a type mismatch */
2456
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2458
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2460
if (flags & SWIG_POINTER_EXCEPTION) {
2461
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2462
SWIG_Python_ArgFail(argnum);
2475
/* -----------------------------------------------------------------------------*
2476
Standard SWIG API for use inside user code.
2478
Don't include this file directly, run the command
2479
swig -python -external-runtime
2480
Also, read the Modules chapter of the SWIG Manual.
2482
* -----------------------------------------------------------------------------*/
2484
#ifdef SWIG_MODULE_CLIENTDATA_TYPE
2486
SWIGRUNTIMEINLINE swig_type_info *
2487
SWIG_TypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata, const char *name) {
2488
swig_module_info *module = SWIG_GetModule(clientdata);
2489
return SWIG_TypeQueryModule(module, module, name);
2492
SWIGRUNTIMEINLINE swig_type_info *
2493
SWIG_MangledTypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata, const char *name) {
2494
swig_module_info *module = SWIG_GetModule(clientdata);
2495
return SWIG_MangledTypeQueryModule(module, module, name);
2500
SWIGRUNTIMEINLINE swig_type_info *
2501
SWIG_TypeQuery(const char *name) {
2502
swig_module_info *module = SWIG_GetModule(NULL);
2503
return SWIG_TypeQueryModule(module, module, name);
2506
SWIGRUNTIMEINLINE swig_type_info *
2507
SWIG_MangledTypeQuery(const char *name) {
2508
swig_module_info *module = SWIG_GetModule(NULL);
2509
return SWIG_MangledTypeQueryModule(module, module, name);
added
removed
src/Base/swigpyrun_1.3.36.h
