17 #ifndef SWIGTEMPLATEDISAMBIGUATOR
18 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
19 # define SWIGTEMPLATEDISAMBIGUATOR template
20 # elif defined(__HP_aCC)
23 # define SWIGTEMPLATEDISAMBIGUATOR template
25 # define SWIGTEMPLATEDISAMBIGUATOR
31 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
32 # define SWIGINLINE inline
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)
59 #ifndef SWIGUNUSEDPARM
61 # define SWIGUNUSEDPARM(p)
63 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
69 # define SWIGINTERN static SWIGUNUSED
73 #ifndef SWIGINTERNINLINE
74 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
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")))
102 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
103 # define SWIGSTDCALL __stdcall
110 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
111 # define _CRT_SECURE_NO_DEPRECATE
115 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
116 # define _SCL_SECURE_NO_DEPRECATE
120 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
121 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
129 #ifdef __INTEL_COMPILER
130 # pragma warning disable 592
133 #define SWIG_UnknownError -1
134 #define SWIG_IOError -2
135 #define SWIG_RuntimeError -3
136 #define SWIG_IndexError -4
137 #define SWIG_TypeError -5
138 #define SWIG_DivisionByZero -6
139 #define SWIG_OverflowError -7
140 #define SWIG_SyntaxError -8
141 #define SWIG_ValueError -9
142 #define SWIG_SystemError -10
143 #define SWIG_AttributeError -11
144 #define SWIG_MemoryError -12
145 #define SWIG_NullReferenceError -13
157 #define SWIG_RUNTIME_VERSION "4"
160 #ifdef SWIG_TYPE_TABLE
161 # define SWIG_QUOTE_STRING(x) #x
162 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
163 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
165 # define SWIG_TYPE_TABLE_NAME
178 # define SWIGRUNTIME SWIGINTERN
181 #ifndef SWIGRUNTIMEINLINE
182 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
186 #ifndef SWIG_BUFFER_SIZE
187 # define SWIG_BUFFER_SIZE 1024
191 #define SWIG_POINTER_DISOWN 0x1
192 #define SWIG_CAST_NEW_MEMORY 0x2
195 #define SWIG_POINTER_OWN 0x1
278 #define SWIG_ERROR (-1)
279 #define SWIG_IsOK(r) (r >= 0)
280 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
283 #define SWIG_CASTRANKLIMIT (1 << 8)
285 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
287 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
289 #define SWIG_BADOBJ (SWIG_ERROR)
290 #define SWIG_OLDOBJ (SWIG_OK)
291 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
292 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
294 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
295 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
296 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
297 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
298 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
299 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
302 #if defined(SWIG_CASTRANK_MODE)
303 # ifndef SWIG_TypeRank
304 # define SWIG_TypeRank unsigned long
306 # ifndef SWIG_MAXCASTRANK
307 # define SWIG_MAXCASTRANK (2)
309 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
310 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
311 SWIGINTERNINLINE
int SWIG_AddCast(
int r) {
312 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
314 SWIGINTERNINLINE
int SWIG_CheckState(
int r) {
315 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
318 # define SWIG_AddCast(r) (r)
319 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
329 typedef void *(*swig_converter_func)(
void *,
int *);
336 swig_dycast_func dcast;
345 swig_converter_func converter;
370 SWIG_TypeNameComp(
const char *f1,
const char *l1,
371 const char *f2,
const char *l2) {
372 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
373 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
374 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
375 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
377 return (
int)((l1 - f1) - (l2 - f2));
385 SWIG_TypeCmp(
const char *nb,
const char *tb) {
387 const char* te = tb + strlen(tb);
389 while (equiv != 0 && *ne) {
390 for (nb = ne; *ne; ++ne) {
391 if (*ne ==
'|')
break;
393 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
404 SWIG_TypeEquiv(
const char *nb,
const char *tb) {
405 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
416 if (strcmp(iter->type->name, c) == 0) {
417 if (iter == ty->cast)
420 iter->prev->next = iter->next;
422 iter->next->prev = iter->prev;
423 iter->next = ty->cast;
425 if (ty->cast) ty->cast->prev = iter;
443 if (iter->type == from) {
444 if (iter == ty->cast)
447 iter->prev->next = iter->next;
449 iter->next->prev = iter->prev;
450 iter->next = ty->cast;
452 if (ty->cast) ty->cast->prev = iter;
465 SWIGRUNTIMEINLINE
void *
467 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
476 if (!ty || !ty->dcast)
return ty;
477 while (ty && (ty->dcast)) {
478 ty = (*ty->dcast)(ptr);
487 SWIGRUNTIMEINLINE
const char *
496 SWIGRUNTIME
const char *
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;
521 ti->clientdata = clientdata;
524 if (!cast->converter) {
526 if (!tc->clientdata) {
527 SWIG_TypeClientData(tc, clientdata);
535 SWIG_TypeClientData(ti, clientdata);
555 size_t r = iter->size - 1;
558 size_t i = (l + r) >> 1;
559 const char *iname = iter->types[i]->name;
561 int compare = strcmp(name, iname);
563 return iter->types[i];
564 }
else if (compare < 0) {
570 }
else if (compare > 0) {
579 }
while (iter != end);
597 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
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);
622 SWIG_PackData(
char *c,
void *ptr,
size_t sz) {
623 static const char hex[17] =
"0123456789abcdef";
624 const unsigned char *u = (
unsigned char *) ptr;
625 const unsigned char *eu = u + sz;
626 for (; u != eu; ++u) {
627 unsigned char uu = *u;
628 *(c++) = hex[(uu & 0xf0) >> 4];
629 *(c++) = hex[uu & 0xf];
637 SWIGRUNTIME
const char *
638 SWIG_UnpackData(
const char *c,
void *ptr,
size_t sz) {
639 unsigned char *u = (
unsigned char *) ptr;
640 const unsigned char *eu = u + sz;
641 for (; u != eu; ++u) {
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));
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 #if PY_VERSION_HEX >= 0x03000000
723 #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
724 #define PyInt_Check(x) PyLong_Check(x)
725 #define PyInt_AsLong(x) PyLong_AsLong(x)
726 #define PyInt_FromLong(x) PyLong_FromLong(x)
727 #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
728 #define PyString_Check(name) PyBytes_Check(name)
729 #define PyString_FromString(x) PyUnicode_FromString(x)
730 #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
731 #define PyString_AsString(str) PyBytes_AsString(str)
732 #define PyString_Size(str) PyBytes_Size(str)
733 #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
734 #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
735 #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
736 #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
741 # define Py_TYPE(op) ((op)->ob_type)
746 #if PY_VERSION_HEX >= 0x03000000
747 # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
749 # define SWIG_Python_str_FromFormat PyString_FromFormat
757 SWIG_Python_str_AsChar(PyObject *str)
759 #if PY_VERSION_HEX >= 0x03000000
763 str = PyUnicode_AsUTF8String(str);
764 PyBytes_AsStringAndSize(str, &cstr, &len);
765 newstr = (
char *) malloc(len+1);
766 memcpy(newstr, cstr, len+1);
770 return PyString_AsString(str);
774 #if PY_VERSION_HEX >= 0x03000000
775 # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
777 # define SWIG_Python_str_DelForPy3(x)
782 SWIG_Python_str_FromChar(
const char *c)
784 #if PY_VERSION_HEX >= 0x03000000
785 return PyUnicode_FromString(c);
787 return PyString_FromString(c);
792 #if PY_VERSION_HEX < 0x02020000
793 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
794 # define PyOS_snprintf _snprintf
796 # define PyOS_snprintf snprintf
801 #if PY_VERSION_HEX < 0x02020000
803 #ifndef SWIG_PYBUFFER_SIZE
804 # define SWIG_PYBUFFER_SIZE 1024
808 PyString_FromFormat(
const char *fmt, ...) {
810 char buf[SWIG_PYBUFFER_SIZE * 2];
813 res = vsnprintf(buf,
sizeof(buf), fmt, ap);
815 return (res < 0 || res >= (
int)
sizeof(buf)) ? 0 : PyString_FromString(buf);
820 #if PY_VERSION_HEX < 0x01060000
821 # define PyObject_Del(op) PyMem_DEL((op))
824 # define PyObject_DEL PyObject_Del
828 #if PY_VERSION_HEX < 0x02020000
829 # ifndef PyExc_StopIteration
830 # define PyExc_StopIteration PyExc_RuntimeError
832 # ifndef PyObject_GenericGetAttr
833 # define PyObject_GenericGetAttr 0
838 #if PY_VERSION_HEX < 0x02010000
839 # ifndef Py_NotImplemented
840 # define Py_NotImplemented PyExc_RuntimeError
845 #if PY_VERSION_HEX < 0x02010000
846 # ifndef PyString_AsStringAndSize
847 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
852 #if PY_VERSION_HEX < 0x02000000
853 # ifndef PySequence_Size
854 # define PySequence_Size PySequence_Length
859 #if PY_VERSION_HEX < 0x02030000
861 PyObject *PyBool_FromLong(
long ok)
863 PyObject *result = ok ? Py_True : Py_False;
872 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
873 typedef int Py_ssize_t;
874 # define PY_SSIZE_T_MAX INT_MAX
875 # define PY_SSIZE_T_MIN INT_MIN
876 typedef inquiry lenfunc;
877 typedef intargfunc ssizeargfunc;
878 typedef intintargfunc ssizessizeargfunc;
879 typedef intobjargproc ssizeobjargproc;
880 typedef intintobjargproc ssizessizeobjargproc;
881 typedef getreadbufferproc readbufferproc;
882 typedef getwritebufferproc writebufferproc;
883 typedef getsegcountproc segcountproc;
884 typedef getcharbufferproc charbufferproc;
885 static long PyNumber_AsSsize_t (PyObject *x,
void *SWIGUNUSEDPARM(exc))
888 PyObject *i = PyNumber_Int(x);
890 result = PyInt_AsLong(i);
897 #if PY_VERSION_HEX < 0x02050000
898 #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
901 #if PY_VERSION_HEX < 0x02040000
902 #define Py_VISIT(op) \
905 int vret = visit((op), arg); \
912 #if PY_VERSION_HEX < 0x02030000
915 PyNumberMethods as_number;
916 PyMappingMethods as_mapping;
917 PySequenceMethods as_sequence;
918 PyBufferProcs as_buffer;
919 PyObject *name, *slots;
923 #if PY_VERSION_HEX < 0x02030000
924 typedef destructor freefunc;
927 #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
928 (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
929 (PY_MAJOR_VERSION > 3))
930 # define SWIGPY_USE_CAPSULE
931 # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
934 #if PY_VERSION_HEX < 0x03020000
935 #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
936 #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
942 SWIGRUNTIME PyObject*
943 SWIG_Python_ErrorType(
int code) {
946 case SWIG_MemoryError:
947 type = PyExc_MemoryError;
950 type = PyExc_IOError;
952 case SWIG_RuntimeError:
953 type = PyExc_RuntimeError;
955 case SWIG_IndexError:
956 type = PyExc_IndexError;
959 type = PyExc_TypeError;
961 case SWIG_DivisionByZero:
962 type = PyExc_ZeroDivisionError;
964 case SWIG_OverflowError:
965 type = PyExc_OverflowError;
967 case SWIG_SyntaxError:
968 type = PyExc_SyntaxError;
970 case SWIG_ValueError:
971 type = PyExc_ValueError;
973 case SWIG_SystemError:
974 type = PyExc_SystemError;
976 case SWIG_AttributeError:
977 type = PyExc_AttributeError;
980 type = PyExc_RuntimeError;
987 SWIG_Python_AddErrorMsg(
const char* mesg)
991 PyObject *traceback = 0;
993 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
996 PyObject *old_str = PyObject_Str(value);
1000 PyErr_Format(type,
"%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1001 SWIG_Python_str_DelForPy3(tmp);
1005 PyErr_SetString(PyExc_RuntimeError, mesg);
1008 #if defined(SWIG_PYTHON_NO_THREADS)
1009 # if defined(SWIG_PYTHON_THREADS)
1010 # undef SWIG_PYTHON_THREADS
1013 #if defined(SWIG_PYTHON_THREADS)
1014 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1015 # if (PY_VERSION_HEX >= 0x02030000)
1016 # define SWIG_PYTHON_USE_GIL
1019 # if defined(SWIG_PYTHON_USE_GIL)
1020 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1021 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1024 class SWIG_Python_Thread_Block {
1026 PyGILState_STATE state;
1028 void end() {
if (status) { PyGILState_Release(state); status =
false;} }
1029 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1030 ~SWIG_Python_Thread_Block() { end(); }
1032 class SWIG_Python_Thread_Allow {
1034 PyThreadState *save;
1036 void end() {
if (status) { PyEval_RestoreThread(save); status =
false; }}
1037 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1038 ~SWIG_Python_Thread_Allow() { end(); }
1040 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1041 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1042 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1043 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1045 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1046 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1047 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1048 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1051 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1052 # define SWIG_PYTHON_INITIALIZE_THREADS
1054 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1055 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1057 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1058 # define SWIG_PYTHON_THREAD_END_BLOCK
1060 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1061 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1063 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1064 # define SWIG_PYTHON_THREAD_END_ALLOW
1068 # define SWIG_PYTHON_INITIALIZE_THREADS
1069 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1070 # define SWIG_PYTHON_THREAD_END_BLOCK
1071 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1072 # define SWIG_PYTHON_THREAD_END_ALLOW
1087 #define SWIG_PY_POINTER 4
1088 #define SWIG_PY_BINARY 5
1105 #if PY_VERSION_HEX >= 0x03000000
1106 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(
self), PyObject *func)
1108 return PyInstanceMethod_New(func);
1111 SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(
self), PyObject *SWIGUNUSEDPARM(func))
1133 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1134 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1135 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1137 #ifdef SWIGPYTHON_BUILTIN
1138 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1140 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1143 #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1145 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1146 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1147 #define swig_owntype int
1150 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1151 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1154 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1155 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1158 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1159 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1162 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1163 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1168 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1169 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1170 #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1172 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1173 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1174 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1175 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1176 #define SWIG_fail goto fail
1184 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1185 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1186 PyErr_SetObject(errtype, obj);
1188 SWIG_PYTHON_THREAD_END_BLOCK;
1192 SWIG_Python_SetErrorMsg(PyObject *errtype,
const char *msg) {
1193 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1194 PyErr_SetString(errtype, msg);
1195 SWIG_PYTHON_THREAD_END_BLOCK;
1198 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1202 #if defined(SWIGPYTHON_BUILTIN)
1205 SwigPyBuiltin_AddPublicSymbol(PyObject *seq,
const char *key) {
1206 PyObject *s = PyString_InternFromString(key);
1207 PyList_Append(seq, s);
1212 SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface,
const char *name, PyObject *obj) {
1213 #if PY_VERSION_HEX < 0x02030000
1214 PyDict_SetItemString(d, (
char *)name, obj);
1216 PyDict_SetItemString(d, name, obj);
1219 if (public_interface)
1220 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1226 SWIG_Python_SetConstant(PyObject *d,
const char *name, PyObject *obj) {
1227 #if PY_VERSION_HEX < 0x02030000
1228 PyDict_SetItemString(d, (
char *)name, obj);
1230 PyDict_SetItemString(d, name, obj);
1239 SWIGINTERN PyObject*
1240 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1241 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1244 }
else if (result == Py_None) {
1248 if (!PyList_Check(result)) {
1249 PyObject *o2 = result;
1250 result = PyList_New(1);
1251 PyList_SetItem(result, 0, o2);
1253 PyList_Append(result,obj);
1262 }
else if (result == Py_None) {
1266 if (!PyTuple_Check(result)) {
1268 result = PyTuple_New(1);
1269 PyTuple_SET_ITEM(result, 0, o2);
1271 o3 = PyTuple_New(1);
1272 PyTuple_SET_ITEM(o3, 0, obj);
1274 result = PySequence_Concat(o2, o3);
1285 SWIG_Python_UnpackTuple(PyObject *args,
const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1291 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got none",
1292 name, (min == max ?
"" :
"at least "), (
int)min);
1296 if (!PyTuple_Check(args)) {
1297 if (min <= 1 && max >= 1) {
1300 for (i = 1; i < max; ++i) {
1305 PyErr_SetString(PyExc_SystemError,
"UnpackTuple() argument list is not a tuple");
1308 Py_ssize_t l = PyTuple_GET_SIZE(args);
1310 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1311 name, (min == max ?
"" :
"at least "), (
int)min, (
int)l);
1313 }
else if (l > max) {
1314 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1315 name, (min == max ?
"" :
"at most "), (
int)max, (
int)l);
1319 for (i = 0; i < l; ++i) {
1320 objs[i] = PyTuple_GET_ITEM(args, i);
1322 for (; l < max; ++l) {
1331 #if PY_VERSION_HEX >= 0x02020000
1332 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1334 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1342 #define SWIG_STATIC_POINTER(var) var
1344 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1352 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1353 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1355 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1357 #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1358 #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1365 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1366 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1367 # ifndef SWIG_PYTHON_BUILD_NONE
1368 # define SWIG_PYTHON_BUILD_NONE
1373 #ifdef SWIG_PYTHON_BUILD_NONE
1376 # define Py_None SWIG_Py_None()
1378 SWIGRUNTIMEINLINE PyObject *
1381 PyObject *none = Py_BuildValue((
char*)
"");
1385 SWIGRUNTIME PyObject *
1388 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1395 SWIGRUNTIMEINLINE PyObject *
1398 PyObject *none = Py_None;
1412 PyTypeObject *pytype;
1415 SWIGRUNTIMEINLINE
int
1419 return data ? data->implicitconv : 0;
1422 SWIGRUNTIMEINLINE PyObject *
1425 PyObject *klass = data ? data->klass : 0;
1426 return (klass ? klass : PyExc_RuntimeError);
1431 SwigPyClientData_New(PyObject* obj)
1439 Py_INCREF(data->klass);
1441 if (PyClass_Check(obj)) {
1443 data->newargs = obj;
1446 #if (PY_VERSION_HEX < 0x02020000)
1449 data->newraw = PyObject_GetAttrString(data->klass, (
char *)
"__new__");
1452 Py_INCREF(data->newraw);
1453 data->newargs = PyTuple_New(1);
1454 PyTuple_SetItem(data->newargs, 0, obj);
1456 data->newargs = obj;
1458 Py_INCREF(data->newargs);
1461 data->destroy = PyObject_GetAttrString(data->klass, (
char *)
"__swig_destroy__");
1462 if (PyErr_Occurred()) {
1466 if (data->destroy) {
1468 Py_INCREF(data->destroy);
1469 flags = PyCFunction_GET_FLAGS(data->destroy);
1471 data->delargs = !(flags & (METH_O));
1478 data->implicitconv = 0;
1486 Py_XDECREF(data->newraw);
1487 Py_XDECREF(data->newargs);
1488 Py_XDECREF(data->destroy);
1499 #ifdef SWIGPYTHON_BUILTIN
1505 #ifdef SWIGPYTHON_BUILTIN
1507 SWIGRUNTIME PyObject *
1508 SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1513 sobj->dict = PyDict_New();
1515 Py_INCREF(sobj->dict);
1521 SWIGRUNTIME PyObject *
1524 return PyLong_FromVoidPtr(v->ptr);
1527 SWIGRUNTIME PyObject *
1530 PyObject *res = NULL;
1531 PyObject *args = PyTuple_New(1);
1533 if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1534 PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1536 #if PY_VERSION_HEX >= 0x03000000
1537 res = PyUnicode_Format(ofmt,args);
1539 res = PyString_Format(ofmt,args);
1549 SWIGRUNTIME PyObject *
1552 return SwigPyObject_format(
"%o",v);
1555 SWIGRUNTIME PyObject *
1558 return SwigPyObject_format(
"%x",v);
1561 SWIGRUNTIME PyObject *
1568 const char *name = SWIG_TypePrettyName(v->ty);
1569 PyObject *repr = SWIG_Python_str_FromFormat(
"<Swig Object of type '%s' at %p>", (name ? name :
"unknown"), (
void *)v);
1572 PyObject *nrep = SwigPyObject_repr((
SwigPyObject *)v->next);
1574 PyObject *nrep = SwigPyObject_repr((
SwigPyObject *)v->next, args);
1576 # if PY_VERSION_HEX >= 0x03000000
1577 PyObject *joined = PyUnicode_Concat(repr, nrep);
1582 PyString_ConcatAndDel(&repr,nrep);
1593 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1597 SWIGRUNTIME PyObject*
1601 if( op != Py_EQ && op != Py_NE ) {
1602 Py_INCREF(Py_NotImplemented);
1603 return Py_NotImplemented;
1605 res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1610 SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(
void);
1612 #ifdef SWIGPYTHON_BUILTIN
1614 SWIGRUNTIME PyTypeObject*
1615 SwigPyObject_type(
void) {
1617 assert(SwigPyObject_stype);
1624 SWIGRUNTIME PyTypeObject*
1625 SwigPyObject_type(
void) {
1626 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1631 SWIGRUNTIMEINLINE
int
1632 SwigPyObject_Check(PyObject *op) {
1633 #ifdef SWIGPYTHON_BUILTIN
1634 PyTypeObject *target_tp = SwigPyObject_type();
1635 if (PyType_IsSubtype(op->ob_type, target_tp))
1637 return (strcmp(op->ob_type->tp_name,
"SwigPyObject") == 0);
1639 return (Py_TYPE(op) == SwigPyObject_type())
1640 || (strcmp(Py_TYPE(op)->tp_name,
"SwigPyObject") == 0);
1644 SWIGRUNTIME PyObject *
1648 SwigPyObject_dealloc(PyObject *v)
1651 PyObject *next = sobj->next;
1652 if (sobj->own == SWIG_POINTER_OWN) {
1655 PyObject *destroy = data ? data->destroy : 0;
1659 if (data->delargs) {
1661 PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1662 res = SWIG_Python_CallFunctor(destroy, tmp);
1665 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1666 PyObject *mself = PyCFunction_GET_SELF(destroy);
1667 res = ((*meth)(mself, v));
1671 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1673 const char *name = SWIG_TypePrettyName(ty);
1674 printf(
"swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name :
"unknown"));
1682 SWIGRUNTIME PyObject*
1683 SwigPyObject_append(PyObject* v, PyObject* next)
1688 if (!PyArg_ParseTuple(next,(
char *)
"O:append", &tmp))
return NULL;
1691 if (!SwigPyObject_Check(next)) {
1696 return SWIG_Py_Void();
1699 SWIGRUNTIME PyObject*
1701 SwigPyObject_next(PyObject* v)
1703 SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1708 Py_INCREF(sobj->next);
1711 return SWIG_Py_Void();
1715 SWIGINTERN PyObject*
1717 SwigPyObject_disown(PyObject *v)
1719 SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1724 return SWIG_Py_Void();
1727 SWIGINTERN PyObject*
1729 SwigPyObject_acquire(PyObject *v)
1731 SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1735 sobj->own = SWIG_POINTER_OWN;
1736 return SWIG_Py_Void();
1739 SWIGINTERN PyObject*
1740 SwigPyObject_own(PyObject *v, PyObject *args)
1743 #if (PY_VERSION_HEX < 0x02020000)
1744 if (!PyArg_ParseTuple(args,(
char *)
"|O:own",&val))
1745 #elif (PY_VERSION_HEX < 0x02050000)
1746 if (!PyArg_UnpackTuple(args, (
char *)
"own", 0, 1, &val))
1748 if (!PyArg_UnpackTuple(args,
"own", 0, 1, &val))
1756 PyObject *obj = PyBool_FromLong(sobj->own);
1759 if (PyObject_IsTrue(val)) {
1760 SwigPyObject_acquire(v);
1762 SwigPyObject_disown(v);
1765 if (PyObject_IsTrue(val)) {
1766 SwigPyObject_acquire(v,args);
1768 SwigPyObject_disown(v,args);
1778 swigobject_methods[] = {
1779 {(
char *)
"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (
char *)
"releases ownership of the pointer"},
1780 {(
char *)
"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (
char *)
"acquires ownership of the pointer"},
1781 {(
char *)
"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (
char *)
"returns/sets ownership of the pointer"},
1782 {(
char *)
"append", (PyCFunction)SwigPyObject_append, METH_O, (
char *)
"appends another 'this' object"},
1783 {(
char *)
"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (
char *)
"returns the next 'this' object"},
1784 {(
char *)
"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (
char *)
"returns object representation"},
1789 swigobject_methods[] = {
1790 {(
char *)
"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (
char *)
"releases ownership of the pointer"},
1791 {(
char *)
"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (
char *)
"acquires ownership of the pointer"},
1792 {(
char *)
"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (
char *)
"returns/sets ownership of the pointer"},
1793 {(
char *)
"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (
char *)
"appends another 'this' object"},
1794 {(
char *)
"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (
char *)
"returns the next 'this' object"},
1795 {(
char *)
"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (
char *)
"returns object representation"},
1800 #if PY_VERSION_HEX < 0x02020000
1801 SWIGINTERN PyObject *
1804 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1808 SWIGRUNTIME PyTypeObject*
1809 SwigPyObject_TypeOnce(
void) {
1810 static char swigobject_doc[] =
"Swig object carries a C/C++ instance pointer";
1812 static PyNumberMethods SwigPyObject_as_number = {
1817 #
if PY_VERSION_HEX < 0x03000000
1833 #
if PY_VERSION_HEX < 0x03000000
1836 (unaryfunc)SwigPyObject_long,
1837 #if PY_VERSION_HEX < 0x03000000
1838 (unaryfunc)SwigPyObject_long,
1843 #if PY_VERSION_HEX < 0x03000000
1844 (unaryfunc)SwigPyObject_oct,
1845 (unaryfunc)SwigPyObject_hex,
1847 #if PY_VERSION_HEX >= 0x03000000
1848 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1849 #elif PY_VERSION_HEX >= 0x02050000
1850 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1851 #elif PY_VERSION_HEX >= 0x02020000
1852 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1853 #elif PY_VERSION_HEX >= 0x02000000
1854 0,0,0,0,0,0,0,0,0,0,0
1858 static PyTypeObject swigpyobject_type;
1859 static int type_init = 0;
1861 const PyTypeObject tmp = {
1863 #if PY_VERSION_HEX >= 0x03000000
1864 PyVarObject_HEAD_INIT(NULL, 0)
1866 PyObject_HEAD_INIT(NULL)
1869 (
char *)
"SwigPyObject",
1872 (destructor)SwigPyObject_dealloc,
1874 #
if PY_VERSION_HEX < 0x02020000
1875 (getattrfunc)SwigPyObject_getattr,
1880 #if PY_VERSION_HEX >= 0x03000000
1883 (cmpfunc)SwigPyObject_compare,
1885 (reprfunc)SwigPyObject_repr,
1886 &SwigPyObject_as_number,
1892 PyObject_GenericGetAttr,
1899 (richcmpfunc)SwigPyObject_richcompare,
1901 #
if PY_VERSION_HEX >= 0x02020000
1923 #
if PY_VERSION_HEX >= 0x02030000
1926 #
if PY_VERSION_HEX >= 0x02060000
1933 swigpyobject_type = tmp;
1935 #if PY_VERSION_HEX < 0x02020000
1936 swigpyobject_type.ob_type = &PyType_Type;
1938 if (PyType_Ready(&swigpyobject_type) < 0)
1942 return &swigpyobject_type;
1945 SWIGRUNTIME PyObject *
1955 return (PyObject *)sobj;
1970 SwigPyPacked_print(
SwigPyPacked *v, FILE *fp,
int SWIGUNUSEDPARM(flags))
1972 char result[SWIG_BUFFER_SIZE];
1973 fputs(
"<Swig Packed ", fp);
1974 if (SWIG_PackDataName(result, v->pack, v->size, 0,
sizeof(result))) {
1978 fputs(v->ty->name,fp);
1983 SWIGRUNTIME PyObject *
1986 char result[SWIG_BUFFER_SIZE];
1987 if (SWIG_PackDataName(result, v->pack, v->size, 0,
sizeof(result))) {
1988 return SWIG_Python_str_FromFormat(
"<Swig Packed at %s%s>", result, v->ty->name);
1990 return SWIG_Python_str_FromFormat(
"<Swig Packed %s>", v->ty->name);
1994 SWIGRUNTIME PyObject *
1997 char result[SWIG_BUFFER_SIZE];
1998 if (SWIG_PackDataName(result, v->pack, v->size, 0,
sizeof(result))){
1999 return SWIG_Python_str_FromFormat(
"%s%s", result, v->ty->name);
2001 return SWIG_Python_str_FromChar(v->ty->name);
2010 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2011 return s ? s : strncmp((
char *)v->pack, (
char *)w->pack, 2*v->size);
2014 SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(
void);
2016 SWIGRUNTIME PyTypeObject*
2017 SwigPyPacked_type(
void) {
2018 static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2022 SWIGRUNTIMEINLINE
int
2023 SwigPyPacked_Check(PyObject *op) {
2024 return ((op)->ob_type == SwigPyPacked_TypeOnce())
2025 || (strcmp((op)->ob_type->tp_name,
"SwigPyPacked") == 0);
2029 SwigPyPacked_dealloc(PyObject *v)
2031 if (SwigPyPacked_Check(v)) {
2038 SWIGRUNTIME PyTypeObject*
2039 SwigPyPacked_TypeOnce(
void) {
2040 static char swigpacked_doc[] =
"Swig object carries a C/C++ instance pointer";
2041 static PyTypeObject swigpypacked_type;
2042 static int type_init = 0;
2044 const PyTypeObject tmp = {
2046 #if PY_VERSION_HEX>=0x03000000
2047 PyVarObject_HEAD_INIT(NULL, 0)
2049 PyObject_HEAD_INIT(NULL)
2052 (
char *)
"SwigPyPacked",
2055 (destructor)SwigPyPacked_dealloc,
2056 (printfunc)SwigPyPacked_print,
2059 #if PY_VERSION_HEX>=0x03000000
2062 (cmpfunc)SwigPyPacked_compare,
2064 (reprfunc)SwigPyPacked_repr,
2070 (reprfunc)SwigPyPacked_str,
2071 PyObject_GenericGetAttr,
2080 #
if PY_VERSION_HEX >= 0x02020000
2102 #
if PY_VERSION_HEX >= 0x02030000
2105 #
if PY_VERSION_HEX >= 0x02060000
2112 swigpypacked_type = tmp;
2114 #if PY_VERSION_HEX < 0x02020000
2115 swigpypacked_type.ob_type = &PyType_Type;
2117 if (PyType_Ready(&swigpypacked_type) < 0)
2121 return &swigpypacked_type;
2124 SWIGRUNTIME PyObject *
2129 void *pack = malloc(size);
2131 memcpy(pack, ptr, size);
2136 PyObject_DEL((PyObject *) sobj);
2140 return (PyObject *) sobj;
2144 SwigPyPacked_UnpackData(PyObject *obj,
void *ptr,
size_t size)
2146 if (SwigPyPacked_Check(obj)) {
2148 if (sobj->size != size)
return 0;
2149 memcpy(ptr, sobj->pack, size);
2160 SWIGRUNTIMEINLINE PyObject *
2163 return SWIG_Python_str_FromChar(
"this");
2166 static PyObject *swig_this = NULL;
2168 SWIGRUNTIME PyObject *
2171 if (swig_this == NULL)
2172 swig_this = _SWIG_This();
2179 #if PY_VERSION_HEX>=0x03000000
2180 #define SWIG_PYTHON_SLOW_GETSET_THIS
2184 SWIG_Python_GetSwigThis(PyObject *pyobj)
2188 if (SwigPyObject_Check(pyobj))
2191 #ifdef SWIGPYTHON_BUILTIN
2193 # ifdef PyWeakref_CheckProxy
2194 if (PyWeakref_CheckProxy(pyobj)) {
2195 pyobj = PyWeakref_GET_OBJECT(pyobj);
2196 if (pyobj && SwigPyObject_Check(pyobj))
2205 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2206 if (PyInstance_Check(pyobj)) {
2207 obj = _PyInstance_Lookup(pyobj, SWIG_This());
2209 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2210 if (dictptr != NULL) {
2211 PyObject *dict = *dictptr;
2212 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2214 #ifdef PyWeakref_CheckProxy
2215 if (PyWeakref_CheckProxy(pyobj)) {
2216 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2217 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2220 obj = PyObject_GetAttr(pyobj,SWIG_This());
2224 if (PyErr_Occurred()) PyErr_Clear();
2230 obj = PyObject_GetAttr(pyobj,SWIG_This());
2234 if (PyErr_Occurred()) PyErr_Clear();
2238 if (obj && !SwigPyObject_Check(obj)) {
2241 return SWIG_Python_GetSwigThis(obj);
2250 SWIG_Python_AcquirePtr(PyObject *obj,
int own) {
2251 if (own == SWIG_POINTER_OWN) {
2254 int oldown = sobj->own;
2265 SWIG_Python_ConvertPtrAndOwn(PyObject *obj,
void **ptr,
swig_type_info *ty,
int flags,
int *own) {
2268 int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2272 if (obj == Py_None && !implicit_conv) {
2280 sobj = SWIG_Python_GetSwigThis(obj);
2284 void *vptr = sobj->ptr;
2289 if (ptr) *ptr = vptr;
2298 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2299 if (newmemory == SWIG_CAST_NEW_MEMORY) {
2302 *own = *own | SWIG_CAST_NEW_MEMORY;
2309 if (ptr) *ptr = vptr;
2315 *own = *own | sobj->own;
2316 if (flags & SWIG_POINTER_DISOWN) {
2321 if (implicit_conv) {
2323 if (data && !data->implicitconv) {
2324 PyObject *klass = data->klass;
2327 data->implicitconv = 1;
2328 impconv = SWIG_Python_CallFunctor(klass, obj);
2329 data->implicitconv = 0;
2330 if (PyErr_Occurred()) {
2338 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2339 if (SWIG_IsOK(res)) {
2344 res = SWIG_AddCast(res);
2345 res = SWIG_AddNewMask(res);
2347 res = SWIG_AddCast(res);
2356 if (!SWIG_IsOK(res) && obj == Py_None) {
2359 if (PyErr_Occurred())
2370 SWIG_Python_ConvertFunctionPtr(PyObject *obj,
void **ptr,
swig_type_info *ty) {
2371 if (!PyCFunction_Check(obj)) {
2372 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2377 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2378 const char *desc = doc ? strstr(doc,
"swig_ptr: ") : 0;
2380 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2387 *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2402 SWIG_Python_ConvertPacked(PyObject *obj,
void *ptr,
size_t sz,
swig_type_info *ty) {
2404 if (!to)
return SWIG_ERROR;
2409 if (!tc)
return SWIG_ERROR;
2424 SWIGRUNTIME PyObject*
2427 #if (PY_VERSION_HEX >= 0x02020000)
2429 PyObject *newraw = data->newraw;
2431 inst = PyObject_Call(newraw, data->newargs, NULL);
2433 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2434 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2435 if (dictptr != NULL) {
2436 PyObject *dict = *dictptr;
2438 dict = PyDict_New();
2440 PyDict_SetItem(dict, SWIG_This(), swig_this);
2444 PyObject *key = SWIG_This();
2445 PyObject_SetAttr(inst, key, swig_this);
2449 #if PY_VERSION_HEX >= 0x03000000
2450 inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2452 PyObject_SetAttr(inst, SWIG_This(), swig_this);
2453 Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2456 PyObject *dict = PyDict_New();
2458 PyDict_SetItem(dict, SWIG_This(), swig_this);
2459 inst = PyInstance_NewRaw(data->newargs, dict);
2466 #if (PY_VERSION_HEX >= 0x02010000)
2468 PyObject *dict = PyDict_New();
2470 PyDict_SetItem(dict, SWIG_This(), swig_this);
2471 inst = PyInstance_NewRaw(data->newargs, dict);
2474 return (PyObject *) inst;
2476 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2480 inst->in_class = (PyClassObject *)data->newargs;
2481 Py_INCREF(inst->in_class);
2482 inst->in_dict = PyDict_New();
2483 if (inst->in_dict == NULL) {
2487 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2488 inst->in_weakreflist = NULL;
2490 #ifdef Py_TPFLAGS_GC
2491 PyObject_GC_Init(inst);
2493 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2494 return (PyObject *) inst;
2500 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2503 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2504 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2505 if (dictptr != NULL) {
2508 dict = PyDict_New();
2511 PyDict_SetItem(dict, SWIG_This(), swig_this);
2515 dict = PyObject_GetAttrString(inst, (
char*)
"__dict__");
2516 PyDict_SetItem(dict, SWIG_This(), swig_this);
2521 SWIGINTERN PyObject *
2522 SWIG_Python_InitShadowInstance(PyObject *args) {
2524 if (!SWIG_Python_UnpackTuple(args,
"swiginit", 2, 2, obj)) {
2529 SwigPyObject_append((PyObject*) sthis, obj[1]);
2531 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2533 return SWIG_Py_Void();
2539 SWIGRUNTIME PyObject *
2540 SWIG_Python_NewPointerObj(PyObject *
self,
void *ptr,
swig_type_info *type,
int flags) {
2546 return SWIG_Py_Void();
2549 own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2550 if (clientdata && clientdata->pytype) {
2552 if (flags & SWIG_BUILTIN_TP_INIT) {
2555 PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2556 while (newobj->next)
2558 newobj->next = next_self;
2560 #ifdef SWIGPYTHON_BUILTIN
2565 newobj = PyObject_New(
SwigPyObject, clientdata->pytype);
2566 #ifdef SWIGPYTHON_BUILTIN
2575 return (PyObject*) newobj;
2577 return SWIG_Py_Void();
2580 assert(!(flags & SWIG_BUILTIN_TP_INIT));
2582 robj = SwigPyObject_New(ptr, type, own);
2583 if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2584 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2593 SWIGRUNTIMEINLINE PyObject *
2594 SWIG_Python_NewPackedObj(
void *ptr,
size_t sz,
swig_type_info *type) {
2595 return ptr ? SwigPyPacked_New((
void *) ptr, sz, type) : SWIG_Py_Void();
2602 #ifdef SWIG_LINK_RUNTIME
2603 void *SWIG_ReturnGlobalTypeList(
void *);
2607 SWIG_Python_GetModule(
void *SWIGUNUSEDPARM(clientdata)) {
2608 static void *type_pointer = (
void *)0;
2610 if (!type_pointer) {
2611 #ifdef SWIG_LINK_RUNTIME
2612 type_pointer = SWIG_ReturnGlobalTypeList((
void *)0);
2614 # ifdef SWIGPY_USE_CAPSULE
2615 type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2617 type_pointer = PyCObject_Import((
char*)
"swig_runtime_data" SWIG_RUNTIME_VERSION,
2618 (
char*)
"type_pointer" SWIG_TYPE_TABLE_NAME);
2620 if (PyErr_Occurred()) {
2622 type_pointer = (
void *)0;
2629 #if PY_MAJOR_VERSION < 2
2633 PyModule_AddObject(PyObject *m,
char *name, PyObject *o)
2636 if (!PyModule_Check(m)) {
2637 PyErr_SetString(PyExc_TypeError,
2638 "PyModule_AddObject() needs module as first arg");
2642 PyErr_SetString(PyExc_TypeError,
2643 "PyModule_AddObject() needs non-NULL value");
2647 dict = PyModule_GetDict(m);
2650 PyErr_Format(PyExc_SystemError,
"module '%s' has no __dict__",
2651 PyModule_GetName(m));
2654 if (PyDict_SetItemString(dict, name, o))
2662 #ifdef SWIGPY_USE_CAPSULE
2663 SWIG_Python_DestroyModule(PyObject *obj)
2665 SWIG_Python_DestroyModule(
void *vptr)
2668 #ifdef SWIGPY_USE_CAPSULE
2675 for (i =0; i < swig_module->size; ++i) {
2679 if (data) SwigPyClientData_Del(data);
2682 Py_DECREF(SWIG_This());
2688 #if PY_VERSION_HEX >= 0x03000000
2690 PyObject *module = PyImport_AddModule((
char*)
"swig_runtime_data" SWIG_RUNTIME_VERSION);
2692 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };
2693 PyObject *module = Py_InitModule((
char*)
"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2695 #ifdef SWIGPY_USE_CAPSULE
2696 PyObject *pointer = PyCapsule_New((
void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2697 if (pointer && module) {
2698 PyModule_AddObject(module, (
char*)
"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2700 Py_XDECREF(pointer);
2703 PyObject *pointer = PyCObject_FromVoidPtr((
void *) swig_module, SWIG_Python_DestroyModule);
2704 if (pointer && module) {
2705 PyModule_AddObject(module, (
char*)
"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2707 Py_XDECREF(pointer);
2713 SWIGRUNTIME PyObject *
2714 SWIG_Python_TypeCache(
void) {
2715 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2720 SWIG_Python_TypeQuery(
const char *type)
2722 PyObject *cache = SWIG_Python_TypeCache();
2723 PyObject *key = SWIG_Python_str_FromChar(type);
2724 PyObject *obj = PyDict_GetItem(cache, key);
2727 #ifdef SWIGPY_USE_CAPSULE
2734 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2736 #ifdef SWIGPY_USE_CAPSULE
2737 obj = PyCapsule_New((
void*) descriptor, NULL, NULL);
2739 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2741 PyDict_SetItem(cache, key, obj);
2752 #define SWIG_POINTER_EXCEPTION 0
2753 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2754 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2757 SWIG_Python_AddErrMesg(
const char* mesg,
int infront)
2759 if (PyErr_Occurred()) {
2761 PyObject *value = 0;
2762 PyObject *traceback = 0;
2763 PyErr_Fetch(&type, &value, &traceback);
2766 PyObject *old_str = PyObject_Str(value);
2770 PyErr_Format(type,
"%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2772 PyErr_Format(type,
"%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2774 SWIG_Python_str_DelForPy3(tmp);
2784 SWIG_Python_ArgFail(
int argnum)
2786 if (PyErr_Occurred()) {
2789 PyOS_snprintf(mesg,
sizeof(mesg),
"argument number %d:", argnum);
2790 return SWIG_Python_AddErrMesg(mesg, 1);
2796 SWIGRUNTIMEINLINE
const char *
2797 SwigPyObject_GetDesc(PyObject *
self)
2801 return ty ? ty->str :
"";
2805 SWIG_Python_TypeError(
const char *type, PyObject *obj)
2808 #if defined(SWIG_COBJECT_TYPES)
2809 if (obj && SwigPyObject_Check(obj)) {
2810 const char *otype = (
const char *) SwigPyObject_GetDesc(obj);
2812 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, 'SwigPyObject(%s)' is received",
2819 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2821 PyObject *str = PyObject_Str(obj);
2822 const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2824 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s(%s)' is received",
2826 SWIG_Python_str_DelForPy3(cstr);
2828 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s' is received",
2835 PyErr_Format(PyExc_TypeError,
"a '%s' is expected", type);
2837 PyErr_Format(PyExc_TypeError,
"unexpected type is received");
2844 SWIG_Python_MustGetPtr(PyObject *obj,
swig_type_info *ty,
int SWIGUNUSEDPARM(argnum),
int flags) {
2846 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2848 #if SWIG_POINTER_EXCEPTION
2850 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2851 SWIG_Python_ArgFail(argnum);
2858 #ifdef SWIGPYTHON_BUILTIN
2860 SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2861 PyTypeObject *tp = obj->ob_type;
2863 PyObject *encoded_name;
2867 # ifdef Py_USING_UNICODE
2868 if (PyString_Check(name)) {
2869 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2872 }
else if (!PyUnicode_Check(name))
2874 if (!PyString_Check(name))
2877 PyErr_Format(PyExc_TypeError,
"attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2884 if (PyType_Ready(tp) < 0)
2888 descr = _PyType_Lookup(tp, name);
2891 f = descr->ob_type->tp_descr_set;
2893 if (PyString_Check(name)) {
2894 encoded_name = name;
2897 encoded_name = PyUnicode_AsUTF8String(name);
2899 PyErr_Format(PyExc_AttributeError,
"'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2900 Py_DECREF(encoded_name);
2902 res = f(descr, obj, value);
2924 #ifdef SWIG_MODULE_CLIENTDATA_TYPE
2927 SWIG_TypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata,
const char *name) {
2929 return SWIG_TypeQueryModule(module, module, name);
2933 SWIG_MangledTypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata,
const char *name) {
2935 return SWIG_MangledTypeQueryModule(module, module, name);
2941 SWIG_TypeQuery(
const char *name) {
2943 return SWIG_TypeQueryModule(module, module, name);
2947 SWIG_MangledTypeQuery(
const char *name) {
2949 return SWIG_MangledTypeQueryModule(module, module, name);
Definition: swigpyrun.h:1405
Definition: swigpyrun.h:913
Definition: swigpyrun.h:1493
Definition: swigpyrun.h:1962
Definition: casadi_oct_swig_octave.cc:372
Definition: swigpyrun.h:1091
Definition: casadi_oct_swig_octave.cc:362
Definition: casadi_oct_swig_octave.cc:382