10#define SWIG_VERSION 0x040200
12#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
20#ifndef SWIGTEMPLATEDISAMBIGUATOR
21# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
22# define SWIGTEMPLATEDISAMBIGUATOR template
23# elif defined(__HP_aCC)
26# define SWIGTEMPLATEDISAMBIGUATOR template
28# define SWIGTEMPLATEDISAMBIGUATOR
34# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
35# define SWIGINLINE inline
44# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
45# define SWIGUNUSED __attribute__ ((__unused__))
50# define SWIGUNUSED __attribute__ ((__unused__))
56#ifndef SWIG_MSC_UNSUPPRESS_4505
58# pragma warning(disable : 4505)
64# define SWIGUNUSEDPARM(p)
66# define SWIGUNUSEDPARM(p) p SWIGUNUSED
72# define SWIGINTERN static SWIGUNUSED
76#ifndef SWIGINTERNINLINE
77# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
82# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
83# ifndef GCC_HASCLASSVISIBILITY
84# define GCC_HASCLASSVISIBILITY
90# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
91# if defined(STATIC_LINKED)
94# define SWIGEXPORT __declspec(dllexport)
97# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
98# define SWIGEXPORT __attribute__ ((visibility("default")))
107# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
108# define SWIGSTDCALL __stdcall
115#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
116# define _CRT_SECURE_NO_DEPRECATE
120#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
121# define _SCL_SECURE_NO_DEPRECATE
125#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
126# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
134#ifdef __INTEL_COMPILER
135# pragma warning disable 592
138#if __cplusplus >=201103L
139# define SWIG_NULLPTR nullptr
141# define SWIG_NULLPTR NULL
145#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
150#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
151#define PY_SSIZE_T_CLEAN
155#pragma GCC diagnostic push
156#if defined(__cplusplus) && __cplusplus >=201703L
157#pragma GCC diagnostic ignored "-Wregister"
161#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
164#if defined(_MSC_VER) && _MSC_VER >= 1929
178#pragma GCC diagnostic pop
192#define SWIG_RUNTIME_VERSION "4"
195#ifdef SWIG_TYPE_TABLE
196# define SWIG_QUOTE_STRING(x) #x
197# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
198# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
200# define SWIG_TYPE_TABLE_NAME
213# define SWIGRUNTIME SWIGINTERN
216#ifndef SWIGRUNTIMEINLINE
217# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
221#ifndef SWIG_BUFFER_SIZE
222# define SWIG_BUFFER_SIZE 1024
226#define SWIG_POINTER_DISOWN 0x1
227#define SWIG_CAST_NEW_MEMORY 0x2
228#define SWIG_POINTER_NO_NULL 0x4
229#define SWIG_POINTER_CLEAR 0x8
230#define SWIG_POINTER_RELEASE (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)
233#define SWIG_POINTER_OWN 0x1
317#define SWIG_ERROR (-1)
321#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)
323#define SWIG_IsOK(r) (r >= 0)
324#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
327#define SWIG_CASTRANKLIMIT (1 << 8)
329#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
331#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
333#define SWIG_BADOBJ (SWIG_ERROR)
334#define SWIG_OLDOBJ (SWIG_OK)
335#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
336#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
338#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
339#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
340#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
341#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
342#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
343#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
346#if defined(SWIG_CASTRANK_MODE)
347# ifndef SWIG_TypeRank
348# define SWIG_TypeRank unsigned long
350# ifndef SWIG_MAXCASTRANK
351# define SWIG_MAXCASTRANK (2)
353# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
354# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
362# define SWIG_AddCast(r) (r)
363# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
369#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
370 (defined __cplusplus && __cplusplus >= 201103L) || \
371 defined SWIG_HAVE_SNPRINTF) && \
372 !defined SWIG_NO_SNPRINTF
373# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
374# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
380# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
381# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
390typedef void *(*swig_converter_func)(
void *,
int *);
432 const char *f2,
const char *l2) {
433 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
434 while ((*f1 ==
' ') && (f1 != l1)) ++f1;
435 while ((*f2 ==
' ') && (f2 != l2)) ++f2;
436 if (*f1 != *f2)
return (*f1 > *f2) ? 1 : -1;
438 return (
int)((l1 - f1) - (l2 - f2));
448 const char* te = tb + strlen(tb);
450 while (equiv != 0 && *ne) {
451 for (nb = ne; *ne; ++ne) {
452 if (*ne ==
'|')
break;
477 if (strcmp(iter->
type->
name, c) == 0) {
478 if (iter == ty->
cast)
504 if (iter->
type == from) {
505 if (iter == ty->
cast)
537 if (!ty || !ty->
dcast)
return ty;
538 while (ty && (ty->
dcast)) {
539 ty = (*ty->
dcast)(ptr);
565 const char *last_name =
type->str;
568 if (*
s ==
'|') last_name =
s+1;
616 size_t r = iter->
size - 1;
619 size_t i = (l + r) >> 1;
620 const char *iname = iter->
types[i]->
name;
622 int compare = strcmp(name, iname);
624 return iter->
types[i];
640 }
while (iter != end);
667 for (; i < iter->
size; ++i) {
669 return iter->
types[i];
672 }
while (iter != end);
684 static const char hex[17] =
"0123456789abcdef";
685 const unsigned char *u = (
unsigned char *) ptr;
686 const unsigned char *eu = u + sz;
687 for (; u != eu; ++u) {
688 unsigned char uu = *u;
689 *(c++) = hex[(uu & 0xf0) >> 4];
690 *(c++) = hex[uu & 0xf];
700 unsigned char *u = (
unsigned char *) ptr;
701 const unsigned char *eu = u + sz;
702 for (; u != eu; ++u) {
705 if ((d >=
'0') && (d <=
'9'))
706 uu = (
unsigned char)((d -
'0') << 4);
707 else if ((d >=
'a') && (d <=
'f'))
708 uu = (
unsigned char)((d - (
'a'-10)) << 4);
712 if ((d >=
'0') && (d <=
'9'))
713 uu |= (
unsigned char)(d -
'0');
714 else if ((d >=
'a') && (d <=
'f'))
715 uu |= (
unsigned char)(d - (
'a'-10));
729 if ((2*
sizeof(
void *) + 2) > bsz)
return 0;
732 if (strlen(name) + 1 > (bsz - (r - buff)))
return 0;
740 if (strcmp(c,
"NULL") == 0) {
753 size_t lname = (name ? strlen(name) : 0);
754 if ((2*sz + 2 + lname) > bsz)
return 0;
758 strncpy(r,name,lname+1);
768 if (strcmp(c,
"NULL") == 0) {
783#define SWIG_UnknownError -1
784#define SWIG_IOError -2
785#define SWIG_RuntimeError -3
786#define SWIG_IndexError -4
787#define SWIG_TypeError -5
788#define SWIG_DivisionByZero -6
789#define SWIG_OverflowError -7
790#define SWIG_SyntaxError -8
791#define SWIG_ValueError -9
792#define SWIG_SystemError -10
793#define SWIG_AttributeError -11
794#define SWIG_MemoryError -12
795#define SWIG_NullReferenceError -13
799#if PY_VERSION_HEX >= 0x03000000
801#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
802#define PyInt_Check(x) PyLong_Check(x)
803#define PyInt_AsLong(x) PyLong_AsLong(x)
804#define PyInt_FromLong(x) PyLong_FromLong(x)
805#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
806#define PyString_Check(name) PyBytes_Check(name)
807#define PyString_FromString(x) PyUnicode_FromString(x)
808#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
809#define PyString_AsString(str) PyBytes_AsString(str)
810#define PyString_Size(str) PyBytes_Size(str)
811#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
812#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
813#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
818# define Py_TYPE(op) ((op)->ob_type)
823#if PY_VERSION_HEX >= 0x03000000
824# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
826# define SWIG_Python_str_FromFormat PyString_FromFormat
834#if PY_VERSION_HEX >= 0x03030000
835# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
837 return PyUnicode_AsUTF8AndSize(
str, psize);
839 *pbytes = PyUnicode_AsUTF8String(
str);
840 const char *chars = *pbytes ? PyBytes_AsString(*pbytes) :
NULL;
842 *psize = PyBytes_Size(*pbytes);
848 PyString_AsStringAndSize(
str, &chars, psize);
856#if PY_VERSION_HEX >= 0x03000000
857 return PyUnicode_FromString(c);
859 return PyString_FromString(c);
864# define PyObject_DEL PyObject_Del
868# define SWIGPY_USE_CAPSULE
869#ifdef SWIGPYTHON_BUILTIN
870# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
872# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
874# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION "." SWIGPY_CAPSULE_ATTR_NAME)
876#if PY_VERSION_HEX < 0x03020000
877#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
878#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
879#define Py_hash_t long
883# define PyTuple_GET_ITEM PyTuple_GetItem
886# define PyTuple_SET_ITEM PyTuple_SetItem
887# define PyTuple_GET_SIZE PyTuple_Size
888# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
889# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
890# define PyCFunction_GET_SELF PyCFunction_GetSelf
891# define PyList_GET_ITEM PyList_GetItem
892# define PyList_SET_ITEM PyList_SetItem
893# define PySliceObject PyObject
905 type = PyExc_MemoryError;
908 type = PyExc_IOError;
911 type = PyExc_RuntimeError;
914 type = PyExc_IndexError;
917 type = PyExc_TypeError;
920 type = PyExc_ZeroDivisionError;
923 type = PyExc_OverflowError;
926 type = PyExc_SyntaxError;
929 type = PyExc_ValueError;
932 type = PyExc_SystemError;
935 type = PyExc_AttributeError;
938 type = PyExc_RuntimeError;
949 PyObject *traceback = 0;
951 if (PyErr_Occurred())
952 PyErr_Fetch(&
type, &value, &traceback);
954 PyObject *old_str = PyObject_Str(value);
955 PyObject *bytes =
NULL;
960 PyErr_Format(
type,
"%s %s", tmp, mesg);
962 PyErr_Format(
type,
"%s", mesg);
967 PyErr_SetString(PyExc_RuntimeError, mesg);
977 error = PyErr_Occurred();
978 return error && PyErr_GivenExceptionMatches(
error, PyExc_TypeError);
988 PyErr_Fetch(&
type, &value, &traceback);
989#if PY_VERSION_HEX >= 0x03000000
990 newvalue = PyUnicode_FromFormat(
"%S\nAdditional information:\n%s", value, message);
992 newvalue = PyString_FromFormat(
"%s\nAdditional information:\n%s", PyString_AsString(value), message);
996 PyErr_Restore(
type, newvalue, traceback);
998 PyErr_Restore(
type, value, traceback);
1002 PyErr_SetString(PyExc_TypeError, message);
1006#if defined(SWIG_PYTHON_NO_THREADS)
1007# if defined(SWIG_PYTHON_THREADS)
1008# undef SWIG_PYTHON_THREADS
1011#if defined(SWIG_PYTHON_THREADS)
1012# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1013# define SWIG_PYTHON_USE_GIL
1015# if defined(SWIG_PYTHON_USE_GIL)
1016# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1017# if PY_VERSION_HEX < 0x03070000
1018# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1020# define SWIG_PYTHON_INITIALIZE_THREADS
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) { status =
false; PyEval_RestoreThread(save); }}
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
1088#define SWIG_PY_POINTER 4
1089#define SWIG_PY_BINARY 5
1115#if PY_VERSION_HEX < 0x02070000
1116# error "This version of SWIG only supports Python >= 2.7"
1119#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03030000
1120# error "This version of SWIG only supports Python 3 >= 3.3"
1126#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1127#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1128#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1130#ifdef SWIGPYTHON_BUILTIN
1131#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1133#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1136#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1138#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1139#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1140#define swig_owntype int
1143#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1144#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1147#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1148#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1151#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1152#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1155#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1156#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1161#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1162#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1163#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1165#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1166#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1167#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1168#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1169#define SWIG_fail goto fail
1179 PyErr_SetObject(errtype, obj);
1187 PyErr_SetString(errtype, msg);
1191#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1195#if defined(SWIGPYTHON_BUILTIN)
1198SwigPyBuiltin_AddPublicSymbol(PyObject *seq,
const char *key) {
1199 PyObject *
s = PyString_InternFromString(key);
1200 PyList_Append(seq,
s);
1206 PyDict_SetItemString(d, name, obj);
1208 if (public_interface)
1209 SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1216 PyDict_SetItemString(d, name, obj);
1228 }
else if (result == Py_None) {
1232 if (!PyList_Check(result)) {
1233 PyObject *o2 = result;
1234 result = PyList_New(1);
1236 PyList_SET_ITEM(result, 0, o2);
1242 PyList_Append(result,obj);
1257 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got none",
1258 name, (min == max ?
"" :
"at least "), (
int)min);
1262 if (!PyTuple_Check(args)) {
1263 if (min <= 1 && max >= 1) {
1266 for (i = 1; i < max; ++i) {
1271 PyErr_SetString(PyExc_SystemError,
"UnpackTuple() argument list is not a tuple");
1274 Py_ssize_t l = PyTuple_GET_SIZE(args);
1276 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1277 name, (min == max ?
"" :
"at least "), (
int)min, (int)l);
1279 }
else if (l > max) {
1280 PyErr_Format(PyExc_TypeError,
"%s expected %s%d arguments, got %d",
1281 name, (min == max ?
"" :
"at most "), (
int)max, (int)l);
1285 for (i = 0; i < l; ++i) {
1286 objs[i] = PyTuple_GET_ITEM(args, i);
1288 for (; l < max; ++l) {
1300 assert(PyDict_Check(kwargs));
1301 if (PyDict_Size(kwargs) > 0) {
1302 PyErr_Format(PyExc_TypeError,
"%s() does not take keyword arguments", name);
1310#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1317#define SWIG_STATIC_POINTER(var) var
1319#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1327#define SWIG_newvarlink() SWIG_Python_newvarlink()
1328#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
1329#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
1337 PyObject *(*get_attr)(void);
1349#if PY_VERSION_HEX >= 0x03000000
1350 return PyUnicode_InternFromString(
"<Swig global variables>");
1352 return PyString_FromString(
"<Swig global variables>");
1359#if PY_VERSION_HEX >= 0x03000000
1360 PyObject *
str = PyUnicode_InternFromString(
"(");
1364 for (var = v->
vars; var; var=var->
next) {
1365 tail = PyUnicode_FromString(var->
name);
1366 joined = PyUnicode_Concat(
str, tail);
1371 tail = PyUnicode_InternFromString(
", ");
1372 joined = PyUnicode_Concat(
str, tail);
1378 tail = PyUnicode_InternFromString(
")");
1379 joined = PyUnicode_Concat(
str, tail);
1384 PyObject *
str = PyString_FromString(
"(");
1386 for (var = v->
vars; var; var=var->
next) {
1387 PyString_ConcatAndDel(&
str,PyString_FromString(var->
name));
1388 if (var->
next) PyString_ConcatAndDel(&
str,PyString_FromString(
", "));
1390 PyString_ConcatAndDel(&
str,PyString_FromString(
")"));
1410 PyObject *res =
NULL;
1413 if (strcmp(var->
name,n) == 0) {
1419 if (res ==
NULL && !PyErr_Occurred()) {
1420 PyErr_Format(PyExc_AttributeError,
"Unknown C global variable '%s'", n);
1431 if (strcmp(var->
name,n) == 0) {
1437 if (res == 1 && !PyErr_Occurred()) {
1438 PyErr_Format(PyExc_AttributeError,
"Unknown C global variable '%s'", n);
1445 static char varlink__doc__[] =
"Swig var link object";
1446#ifndef Py_LIMITED_API
1447 static PyTypeObject varlink_type;
1448 static int type_init = 0;
1450 const PyTypeObject tmp = {
1451#if PY_VERSION_HEX >= 0x03000000
1452 PyVarObject_HEAD_INIT(
NULL, 0)
1454 PyObject_HEAD_INIT(
NULL)
1461#if PY_VERSION_HEX < 0x030800b4
1485 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1488#if PY_VERSION_HEX >= 0x03040000
1491#if PY_VERSION_HEX >= 0x03080000
1494#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
1497#if PY_VERSION_HEX >= 0x030C0000
1510 if (PyType_Ready(&varlink_type) < 0)
1513 return &varlink_type;
1515 PyType_Slot slots[] = {
1521 { Py_tp_doc, (
void *)varlink__doc__ },
1524 PyType_Spec spec = {
1531 return (PyTypeObject *)PyType_FromSpec(&spec);
1542 return ((PyObject*) result);
1550 size_t size = strlen(name)+1;
1553 memcpy(gv->
name, name, size);
1582#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1583#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1585#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1587#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1588#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1599 PyObject *
none = Py_None;
1620 int fail =
data ?
data->implicitconv : 0;
1622 PyErr_SetString(PyExc_TypeError,
"Implicit conversion is prohibited for explicit constructors.");
1629 PyObject *klass =
data ?
data->klass : 0;
1630 return (klass ? klass : PyExc_RuntimeError);
1643 Py_INCREF(
data->klass);
1645 if (PyClass_Check(obj)) {
1648 data->newargs = obj;
1650 data->newraw = PyObject_GetAttrString(
data->klass,
"__new__");
1652 data->newargs = PyTuple_New(1);
1653 if (
data->newargs) {
1655 PyTuple_SET_ITEM(
data->newargs, 0, obj);
1657 Py_DECREF(
data->newraw);
1658 Py_DECREF(
data->klass);
1664 data->newargs = obj;
1668 data->destroy = PyObject_GetAttrString(
data->klass,
"__swig_destroy__");
1669 if (PyErr_Occurred()) {
1673 if (
data->destroy) {
1674 data->delargs = !(PyCFunction_GET_FLAGS(
data->destroy) & METH_O);
1678 data->implicitconv = 0;
1687 Py_XDECREF(
data->klass);
1688 Py_XDECREF(
data->newraw);
1689 Py_XDECREF(
data->newargs);
1690 Py_XDECREF(
data->destroy);
1702#ifdef SWIGPYTHON_BUILTIN
1708#ifdef SWIGPYTHON_BUILTIN
1711SwigPyObject_get___dict__(PyObject *v, PyObject *
SWIGUNUSEDPARM(args))
1716 sobj->dict = PyDict_New();
1718 Py_XINCREF(sobj->dict);
1727 return PyLong_FromVoidPtr(v->
ptr);
1733 PyObject *res =
NULL;
1734 PyObject *args = PyTuple_New(1);
1739 PyTuple_SET_ITEM(args, 0, val);
1742#if PY_VERSION_HEX >= 0x03000000
1743 res = PyUnicode_Format(ofmt,args);
1745 res = PyString_Format(ofmt,args);
1772 if (repr && v->
next) {
1775# if PY_VERSION_HEX >= 0x03000000
1776 PyObject *joined = PyUnicode_Concat(repr, nrep);
1781 PyString_ConcatAndDel(&repr,nrep);
1804 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1811 PyObject* res =
NULL;
1812 if (!PyErr_Occurred()) {
1813 if (op != Py_EQ && op != Py_NE) {
1814 Py_INCREF(Py_NotImplemented);
1815 return Py_NotImplemented;
1825#ifdef SWIGPYTHON_BUILTIN
1830 assert(SwigPyObject_stype);
1847 PyTypeObject *op_type =
Py_TYPE(op);
1848#ifdef SWIGPYTHON_BUILTIN
1849 if (PyType_IsSubtype(op_type, target_tp))
1851 return (strcmp(op_type->tp_name,
"SwigPyObject") == 0);
1853 if (op_type == target_tp)
1855# ifdef Py_LIMITED_API
1857 PyObject *tp_name = PyObject_GetAttrString((PyObject *)op_type,
"__name__");
1860 cmp = PyUnicode_CompareWithASCIIString(tp_name,
"SwigPyObject");
1864 return (strcmp(op_type->tp_name,
"SwigPyObject") == 0);
1878 PyObject *next = sobj->
next;
1882 PyObject *destroy =
data ?
data->destroy : 0;
1895 PyErr_Fetch(&
type, &value, &traceback);
1897 if (
data->delargs) {
1907 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1908 PyObject *mself = PyCFunction_GET_SELF(destroy);
1909 res = ((*meth)(mself, v));
1912 PyErr_WriteUnraisable(destroy);
1914 PyErr_Restore(
type, value, traceback);
1918#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1921 printf(
"swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name :
"unknown"));
1927#ifdef SWIGPYTHON_BUILTIN
1928 Py_XDECREF(sobj->dict);
1938 PyErr_SetString(PyExc_TypeError,
"Attempt to append a non SwigPyObject");
1952 Py_INCREF(sobj->
next);
1979 if (!PyArg_UnpackTuple(args,
"own", 0, 1, &val)) {
1983 PyObject *obj = PyBool_FromLong(sobj->
own);
1985 if (PyObject_IsTrue(val)) {
1999 {
"own",
SwigPyObject_own, METH_VARARGS,
"returns/sets ownership of the pointer"},
2008 static char swigobject_doc[] =
"Swig object carries a C/C++ instance pointer";
2009#ifndef Py_LIMITED_API
2010 static PyNumberMethods SwigPyObject_as_number = {
2015#
if PY_VERSION_HEX < 0x03000000
2031#
if PY_VERSION_HEX < 0x03000000
2035#if PY_VERSION_HEX < 0x03000000
2041#if PY_VERSION_HEX < 0x03000000
2045#if PY_VERSION_HEX >= 0x03050000
2046 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
2047#elif PY_VERSION_HEX >= 0x03000000
2048 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
2050 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
2054 static PyTypeObject swigpyobject_type;
2055 static int type_init = 0;
2057 const PyTypeObject tmp = {
2058#if PY_VERSION_HEX >= 0x03000000
2059 PyVarObject_HEAD_INIT(
NULL, 0)
2061 PyObject_HEAD_INIT(
NULL)
2068#if PY_VERSION_HEX < 0x030800b4
2075#if PY_VERSION_HEX >= 0x03000000
2081 &SwigPyObject_as_number,
2087 PyObject_GenericGetAttr,
2118#
if PY_VERSION_HEX >= 0x03040000
2121#
if PY_VERSION_HEX >= 0x03080000
2124#
if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2127#
if PY_VERSION_HEX >= 0x030C0000
2138 swigpyobject_type = tmp;
2140 if (PyType_Ready(&swigpyobject_type) != 0)
2143 return &swigpyobject_type;
2145 PyType_Slot slots[] = {
2148 { Py_tp_getattro, (
void *)PyObject_GenericGetAttr },
2149 { Py_tp_doc, (
void *)swigobject_doc },
2155 PyType_Spec spec = {
2162 return (PyTypeObject *)PyType_FromSpec(&spec);
2175#ifdef SWIGPYTHON_BUILTIN
2185 return (PyObject *)sobj;
2226 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2227 return s ?
s : strncmp((
const char *)v->
pack, (
const char *)w->
pack, 2*v->
size);
2240 PyTypeObject* op_type =
Py_TYPE(op);
2243#ifdef Py_LIMITED_API
2245 PyObject *tp_name = PyObject_GetAttrString((PyObject *)op_type,
"__name__");
2248 cmp = PyUnicode_CompareWithASCIIString(tp_name,
"SwigPyPacked");
2252 return (strcmp(op_type->tp_name,
"SwigPyPacked") == 0);
2268 static char swigpacked_doc[] =
"Swig object carries a C/C++ instance pointer";
2269#ifndef Py_LIMITED_API
2270 static PyTypeObject swigpypacked_type;
2271 static int type_init = 0;
2273 const PyTypeObject tmp = {
2274#if PY_VERSION_HEX>=0x03000000
2275 PyVarObject_HEAD_INIT(
NULL, 0)
2277 PyObject_HEAD_INIT(
NULL)
2284#if PY_VERSION_HEX < 0x030800b4
2291#if PY_VERSION_HEX>=0x03000000
2303 PyObject_GenericGetAttr,
2334#
if PY_VERSION_HEX >= 0x03040000
2337#
if PY_VERSION_HEX >= 0x03080000
2340#
if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
2343#
if PY_VERSION_HEX >= 0x030C0000
2354 swigpypacked_type = tmp;
2356 if (PyType_Ready(&swigpypacked_type) != 0)
2359 return &swigpypacked_type;
2361 PyType_Slot slots[] = {
2365 { Py_tp_getattro, (
void *)PyObject_GenericGetAttr },
2366 { Py_tp_doc, (
void *)swigpacked_doc },
2369 PyType_Spec spec = {
2376 return (PyTypeObject *)PyType_FromSpec(&spec);
2385 void *pack =
malloc(size);
2387 memcpy(pack, ptr, size);
2396 return (PyObject *) sobj;
2404 if (sobj->
size != size)
return 0;
2405 memcpy(ptr, sobj->
pack, size);
2429#if PY_VERSION_HEX>=0x03000000
2430#define SWIG_PYTHON_SLOW_GETSET_THIS
2441#ifdef SWIGPYTHON_BUILTIN
2443# ifdef PyWeakref_CheckProxy
2444 if (PyWeakref_CheckProxy(pyobj)) {
2445 pyobj = PyWeakref_GET_OBJECT(pyobj);
2455#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2456 if (PyInstance_Check(pyobj)) {
2457 obj = _PyInstance_Lookup(pyobj,
SWIG_This());
2459 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2460 if (dictptr !=
NULL) {
2461 PyObject *dict = *dictptr;
2462 obj = dict ? PyDict_GetItem(dict,
SWIG_This()) : 0;
2464#ifdef PyWeakref_CheckProxy
2465 if (PyWeakref_CheckProxy(pyobj)) {
2466 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2470 obj = PyObject_GetAttr(pyobj,
SWIG_This());
2474 if (PyErr_Occurred()) PyErr_Clear();
2480 obj = PyObject_GetAttr(pyobj,
SWIG_This());
2484 if (PyErr_Occurred()) PyErr_Clear();
2504 int oldown = sobj->
own;
2522 if (obj == Py_None && !implicit_conv) {
2534 void *vptr = sobj->
ptr;
2539 if (ptr) *ptr = vptr;
2559 if (ptr) *ptr = vptr;
2568 *own = *own | sobj->
own;
2578 if (implicit_conv) {
2581 PyObject *klass =
data->klass;
2584 data->implicitconv = 1;
2586 data->implicitconv = 0;
2587 if (PyErr_Occurred()) {
2612 if (!
SWIG_IsOK(res) && obj == Py_None) {
2615 if (PyErr_Occurred())
2628 if (!PyCFunction_Check(obj)) {
2635#ifndef Py_LIMITED_API
2636 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2638 PyObject* pystr_doc = PyObject_GetAttrString(obj,
"__doc__");
2639 PyObject *bytes =
NULL;
2642 const char *desc = doc ? strstr(doc,
"swig_ptr: ") : 0;
2645#ifdef Py_LIMITED_API
2647 Py_XDECREF(pystr_doc);
2692 PyObject *newraw =
data->newraw;
2694 inst = PyObject_Call(newraw,
data->newargs,
NULL);
2696#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2697 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2698 if (dictptr !=
NULL) {
2699 PyObject *dict = *dictptr;
2701 dict = PyDict_New();
2705 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2712 if (PyObject_SetAttr(inst,
SWIG_This(), swig_this) == -1) {
2719#if PY_VERSION_HEX >= 0x03000000
2720 PyObject *empty_args = PyTuple_New(0);
2722 PyObject *empty_kwargs = PyDict_New();
2724#ifndef Py_LIMITED_API
2725 newfunc newfn = ((PyTypeObject *)
data->newargs)->tp_new;
2727 newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)
data->newargs, Py_tp_new);
2729 inst = newfn((PyTypeObject *)
data->newargs, empty_args, empty_kwargs);
2730 Py_DECREF(empty_kwargs);
2732 if (PyObject_SetAttr(inst,
SWIG_This(), swig_this) == -1) {
2736 PyType_Modified(
Py_TYPE(inst));
2740 Py_DECREF(empty_args);
2743 PyObject *dict = PyDict_New();
2745 PyDict_SetItem(dict,
SWIG_This(), swig_this);
2746 inst = PyInstance_NewRaw(
data->newargs, dict);
2757#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2758 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2759 if (dictptr !=
NULL) {
2760 PyObject *dict = *dictptr;
2762 dict = PyDict_New();
2766 return PyDict_SetItem(dict,
SWIG_This(), swig_this);
2772 return PyObject_SetAttr(inst,
SWIG_This(), swig_this);
2806 if (clientdata && clientdata->
pytype) {
2811#ifndef Py_LIMITED_API
2812 allocfunc alloc = clientdata->
pytype->tp_alloc;
2814 allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->
pytype, Py_tp_alloc);
2816 PyObject *next_self = alloc(clientdata->
pytype, 0);
2817 while (newobj->
next)
2819 newobj->
next = next_self;
2821#ifdef SWIGPYTHON_BUILTIN
2827#ifdef SWIGPYTHON_BUILTIN
2838 return (PyObject*) newobj;
2865#ifdef SWIG_LINK_RUNTIME
2866void *SWIG_ReturnGlobalTypeList(
void *);
2882#ifdef SWIG_LINK_RUNTIME
2883 static void *type_pointer = (
void *)0;
2885 if (!type_pointer) {
2886 type_pointer = SWIG_ReturnGlobalTypeList((
void *)0);
2890 if (PyErr_Occurred()) {
2892 type_pointer = (
void *)0;
2928#if PY_VERSION_HEX >= 0x03000000
2930 PyObject *
module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
2932 static PyMethodDef swig_empty_runtime_method_table[] = { {
NULL,
NULL, 0,
NULL} };
2933 PyObject *
module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2936 if (pointer && module) {
2944 Py_XDECREF(pointer);
2953 PyObject *obj = PyDict_GetItem(cache, key);
2961 obj = PyCapsule_New((
void*) descriptor,
NULL,
NULL);
2963 PyDict_SetItem(cache, key, obj);
2975#define SWIG_POINTER_EXCEPTION 0
2976#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2977#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2982 if (PyErr_Occurred()) {
2984 PyObject *value = 0;
2985 PyObject *traceback = 0;
2986 PyErr_Fetch(&
type, &value, &traceback);
2988 PyObject *old_str = PyObject_Str(value);
2989 PyObject *bytes =
NULL;
2991 const char *errmesg = tmp ? tmp :
"Invalid error message";
2995 PyErr_Format(
type,
"%s %s", mesg, errmesg);
2997 PyErr_Format(
type,
"%s %s", errmesg, mesg);
3011 if (PyErr_Occurred()) {
3014 PyOS_snprintf(mesg,
sizeof(mesg),
"argument number %d:", argnum);
3026 return ty ? ty->
str :
"";
3033#if defined(SWIG_COBJECT_TYPES)
3037 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, 'SwigPyObject(%s)' is received",
3044#ifndef Py_LIMITED_API
3046 const char *otype = (obj ? obj->ob_type->tp_name : 0);
3048 PyObject *
str = PyObject_Str(obj);
3049 PyObject *bytes =
NULL;
3052 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s(%s)' is received",
3055 PyErr_Format(PyExc_TypeError,
"a '%s' is expected, '%s' is received",
3064 PyErr_Format(PyExc_TypeError,
"a '%s' is expected",
type);
3066 PyErr_Format(PyExc_TypeError,
"unexpected type is received");
3081#ifdef SWIGPYTHON_BUILTIN
3083SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
3084 PyTypeObject *tp = obj->ob_type;
3086 PyObject *encoded_name;
3090# ifdef Py_USING_UNICODE
3091 if (PyString_Check(name)) {
3092 name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name),
NULL,
NULL);
3095 }
else if (!PyUnicode_Check(name))
3097 if (!PyString_Check(name))
3100 PyErr_Format(PyExc_TypeError,
"attribute name must be string, not '%.200s'", name->ob_type->tp_name);
3107 if (PyType_Ready(tp) != 0)
3111 descr = _PyType_Lookup(tp, name);
3114 f = descr->ob_type->tp_descr_set;
3116 if (PyString_Check(name)) {
3117 encoded_name = name;
3120 encoded_name = PyUnicode_AsUTF8String(name);
3124 PyErr_Format(PyExc_AttributeError,
"'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
3125 Py_DECREF(encoded_name);
3127 res = f(descr, obj, value);
3143#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
3145#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0)
3151#define SWIGTYPE_p_Agedge_t swig_types[0]
3152#define SWIGTYPE_p_Agnode_t swig_types[1]
3153#define SWIGTYPE_p_Agraph_t swig_types[2]
3154#define SWIGTYPE_p_Agsym_t swig_types[3]
3155#define SWIGTYPE_p_FILE swig_types[4]
3156#define SWIGTYPE_p_char swig_types[5]
3159#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3160#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3164#ifdef SWIG_TypeQuery
3165# undef SWIG_TypeQuery
3167#define SWIG_TypeQuery SWIG_Python_TypeQuery
3172#if PY_VERSION_HEX >= 0x03000000
3173# define SWIG_init PyInit__gv
3176# define SWIG_init init_gv
3179#define SWIG_name "_gv"
3184template<
typename T>
class SwigValueWrapper {
3185 struct SwigSmartPointer {
3187 SwigSmartPointer(
T *p) : ptr(p) { }
3188 ~SwigSmartPointer() {
delete ptr; }
3189 SwigSmartPointer& operator=(SwigSmartPointer& rhs) {
T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = rhs.ptr; rhs.ptr = 0;
return *
this; }
3190 void reset(
T *p) {
T* oldptr = ptr; ptr = 0;
delete oldptr; ptr = p; }
3192 SwigValueWrapper& operator=(
const SwigValueWrapper<T>& rhs);
3193 SwigValueWrapper(
const SwigValueWrapper<T>& rhs);
3195 SwigValueWrapper() : pointer(0) { }
3196 SwigValueWrapper& operator=(
const T& t) { SwigSmartPointer tmp(
new T(t)); pointer = tmp;
return *
this; }
3197#if __cplusplus >=201103L
3198 SwigValueWrapper& operator=(
T&& t) { SwigSmartPointer tmp(
new T(std::move(t))); pointer = tmp;
return *
this; }
3199 operator T&&()
const {
return std::move(*pointer.ptr); }
3201 operator T&()
const {
return *pointer.ptr; }
3203 T *operator&()
const {
return pointer.ptr; }
3204 static void reset(SwigValueWrapper& t,
T *p) { t.pointer.reset(p); }
3216template <
typename T>
T SwigValueInit() {
3220#if __cplusplus >=201103L
3221# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
3223# define SWIG_STD_MOVE(OBJ) OBJ
3229#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
3230#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
3265 Py_XINCREF(
item._obj);
3279 operator PyObject *()
const
3494 static int init = 0;
3509#if PY_VERSION_HEX>=0x03000000
3510#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3511 if (PyBytes_Check(obj))
3513 if (PyUnicode_Check(obj))
3516 if (PyString_Check(obj))
3519 char *cstr; Py_ssize_t
len;
3520 PyObject *bytes =
NULL;
3524#if PY_VERSION_HEX>=0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3525 if (PyBytes_AsStringAndSize(obj, &cstr, &
len) == -1)
3532 if (bytes && cptr) {
3534 cstr =
reinterpret_cast< char*
>(memcpy(
new char[
len + 1], cstr,
sizeof(
char)*(
len + 1)));
3542 if (cptr) *cptr = cstr;
3543 if (psize) *psize =
len + 1;
3547#if defined(SWIG_PYTHON_2_UNICODE)
3548#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3549#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3551#if PY_VERSION_HEX<0x03000000
3552 if (PyUnicode_Check(obj)) {
3553 char *cstr; Py_ssize_t
len;
3554 if (!alloc && cptr) {
3557 obj = PyUnicode_AsUTF8String(obj);
3560 if (PyString_AsStringAndSize(obj, &cstr, &
len) != -1) {
3563 *cptr =
reinterpret_cast< char*
>(memcpy(
new char[
len + 1], cstr,
sizeof(
char)*(
len + 1)));
3565 if (psize) *psize =
len + 1;
3577 if (pchar_descriptor) {
3580 if (cptr) *cptr = (
char *) vptr;
3581 if (psize) *psize = vptr ? (strlen((
char *)vptr) + 1) : 0;
3598 if (size > INT_MAX) {
3600 return pchar_descriptor ?
3603#if PY_VERSION_HEX >= 0x03000000
3604#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3605 return PyBytes_FromStringAndSize(carray,
static_cast< Py_ssize_t
>(size));
3607 return PyUnicode_DecodeUTF8(carray,
static_cast< Py_ssize_t
>(size),
"surrogateescape");
3610 return PyString_FromStringAndSize(carray,
static_cast< Py_ssize_t
>(size));
3629 return PyBool_FromLong(value ? 1 : 0);
3636 PyObject *resultobj = 0;
3637 char *arg1 = (
char *) 0 ;
3644 if ((nobjs < 1) || (nobjs > 1))
SWIG_fail;
3649 arg1 =
reinterpret_cast< char *
>(buf1);
3661 PyObject *resultobj = 0;
3662 char *arg1 = (
char *) 0 ;
3666 PyObject *swig_obj[1] ;
3676 arg1 =
reinterpret_cast< char *
>(buf1);
3688 PyObject *resultobj = 0;
3689 char *arg1 = (
char *) 0 ;
3693 PyObject *swig_obj[1] ;
3703 arg1 =
reinterpret_cast< char *
>(buf1);
3715 PyObject *resultobj = 0;
3716 char *arg1 = (
char *) 0 ;
3720 PyObject *swig_obj[1] ;
3730 arg1 =
reinterpret_cast< char *
>(buf1);
3742 PyObject *resultobj = 0;
3743 char *arg1 = (
char *) 0 ;
3747 PyObject *swig_obj[1] ;
3757 arg1 =
reinterpret_cast< char *
>(buf1);
3769 PyObject *resultobj = 0;
3770 char *arg1 = (
char *) 0 ;
3777 if ((nobjs < 1) || (nobjs > 1))
SWIG_fail;
3782 arg1 =
reinterpret_cast< char *
>(buf1);
3794 PyObject *resultobj = 0;
3795 FILE *arg1 = (FILE *) 0 ;
3801 if ((nobjs < 1) || (nobjs > 1))
SWIG_fail;
3806 arg1 =
reinterpret_cast< FILE *
>(argp1);
3817 PyObject *argv[2] = {
3843 " Possible C/C++ prototypes are:\n"
3844 " read(char const *)\n"
3851 PyObject *resultobj = 0;
3853 char *arg2 = (
char *) 0 ;
3862 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
3867 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
3872 arg2 =
reinterpret_cast< char *
>(buf2);
3885 PyObject *argv[3] = {
3915 " Possible C/C++ prototypes are:\n"
3917 " graph(Agraph_t *,char *)\n");
3923 PyObject *resultobj = 0;
3925 char *arg2 = (
char *) 0 ;
3931 PyObject *swig_obj[2] ;
3940 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
3945 arg2 =
reinterpret_cast< char *
>(buf2);
3957 PyObject *resultobj = 0;
3967 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
3972 arg1 =
reinterpret_cast< Agnode_t *
>(argp1);
3977 arg2 =
reinterpret_cast< Agnode_t *
>(argp2);
3987 PyObject *resultobj = 0;
3989 char *arg2 = (
char *) 0 ;
3998 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
4003 arg1 =
reinterpret_cast< Agnode_t *
>(argp1);
4008 arg2 =
reinterpret_cast< char *
>(buf2);
4020 PyObject *resultobj = 0;
4021 char *arg1 = (
char *) 0 ;
4031 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
4036 arg1 =
reinterpret_cast< char *
>(buf1);
4041 arg2 =
reinterpret_cast< Agnode_t *
>(argp2);
4053 PyObject *resultobj = 0;
4055 char *arg2 = (
char *) 0 ;
4056 char *arg3 = (
char *) 0 ;
4068 if ((nobjs < 3) || (nobjs > 3))
SWIG_fail;
4073 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
4078 arg2 =
reinterpret_cast< char *
>(buf2);
4083 arg3 =
reinterpret_cast< char *
>(buf3);
4098 PyObject *argv[4] = {
4164 " Possible C/C++ prototypes are:\n"
4165 " edge(Agnode_t *,Agnode_t *)\n"
4166 " edge(Agnode_t *,char *)\n"
4167 " edge(char *,Agnode_t *)\n"
4168 " edge(Agraph_t *,char *,char *)\n");
4174 PyObject *resultobj = 0;
4176 char *arg2 = (
char *) 0 ;
4177 char *arg3 = (
char *) 0 ;
4189 if ((nobjs < 3) || (nobjs > 3))
SWIG_fail;
4194 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
4199 arg2 =
reinterpret_cast< char *
>(buf2);
4204 arg3 =
reinterpret_cast< char *
>(buf3);
4205 result = (
char *)
setv(arg1,arg2,arg3);
4218 PyObject *resultobj = 0;
4220 char *arg2 = (
char *) 0 ;
4221 char *arg3 = (
char *) 0 ;
4233 if ((nobjs < 3) || (nobjs > 3))
SWIG_fail;
4238 arg1 =
reinterpret_cast< Agnode_t *
>(argp1);
4243 arg2 =
reinterpret_cast< char *
>(buf2);
4248 arg3 =
reinterpret_cast< char *
>(buf3);
4249 result = (
char *)
setv(arg1,arg2,arg3);
4262 PyObject *resultobj = 0;
4264 char *arg2 = (
char *) 0 ;
4265 char *arg3 = (
char *) 0 ;
4277 if ((nobjs < 3) || (nobjs > 3))
SWIG_fail;
4282 arg1 =
reinterpret_cast< Agedge_t *
>(argp1);
4287 arg2 =
reinterpret_cast< char *
>(buf2);
4292 arg3 =
reinterpret_cast< char *
>(buf3);
4293 result = (
char *)
setv(arg1,arg2,arg3);
4306 PyObject *resultobj = 0;
4309 char *arg3 = (
char *) 0 ;
4320 if ((nobjs < 3) || (nobjs > 3))
SWIG_fail;
4325 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
4330 arg2 =
reinterpret_cast< Agsym_t *
>(argp2);
4335 arg3 =
reinterpret_cast< char *
>(buf3);
4336 result = (
char *)
setv(arg1,arg2,arg3);
4347 PyObject *resultobj = 0;
4350 char *arg3 = (
char *) 0 ;
4361 if ((nobjs < 3) || (nobjs > 3))
SWIG_fail;
4366 arg1 =
reinterpret_cast< Agnode_t *
>(argp1);
4371 arg2 =
reinterpret_cast< Agsym_t *
>(argp2);
4376 arg3 =
reinterpret_cast< char *
>(buf3);
4377 result = (
char *)
setv(arg1,arg2,arg3);
4388 PyObject *resultobj = 0;
4391 char *arg3 = (
char *) 0 ;
4402 if ((nobjs < 3) || (nobjs > 3))
SWIG_fail;
4407 arg1 =
reinterpret_cast< Agedge_t *
>(argp1);
4412 arg2 =
reinterpret_cast< Agsym_t *
>(argp2);
4417 arg3 =
reinterpret_cast< char *
>(buf3);
4418 result = (
char *)
setv(arg1,arg2,arg3);
4430 PyObject *argv[4] = {
4544 " Possible C/C++ prototypes are:\n"
4545 " setv(Agraph_t *,char *,char *)\n"
4546 " setv(Agnode_t *,char *,char *)\n"
4547 " setv(Agedge_t *,char *,char *)\n"
4548 " setv(Agraph_t *,Agsym_t *,char *)\n"
4549 " setv(Agnode_t *,Agsym_t *,char *)\n"
4550 " setv(Agedge_t *,Agsym_t *,char *)\n");
4556 PyObject *resultobj = 0;
4558 char *arg2 = (
char *) 0 ;
4567 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
4572 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
4577 arg2 =
reinterpret_cast< char *
>(buf2);
4578 result = (
char *)
getv(arg1,arg2);
4589 PyObject *resultobj = 0;
4591 char *arg2 = (
char *) 0 ;
4600 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
4605 arg1 =
reinterpret_cast< Agnode_t *
>(argp1);
4610 arg2 =
reinterpret_cast< char *
>(buf2);
4611 result = (
char *)
getv(arg1,arg2);
4622 PyObject *resultobj = 0;
4624 char *arg2 = (
char *) 0 ;
4633 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
4638 arg1 =
reinterpret_cast< Agedge_t *
>(argp1);
4643 arg2 =
reinterpret_cast< char *
>(buf2);
4644 result = (
char *)
getv(arg1,arg2);
4655 PyObject *resultobj = 0;
4665 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
4670 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
4675 arg2 =
reinterpret_cast< Agsym_t *
>(argp2);
4676 result = (
char *)
getv(arg1,arg2);
4685 PyObject *resultobj = 0;
4695 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
4700 arg1 =
reinterpret_cast< Agnode_t *
>(argp1);
4705 arg2 =
reinterpret_cast< Agsym_t *
>(argp2);
4706 result = (
char *)
getv(arg1,arg2);
4715 PyObject *resultobj = 0;
4725 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
4730 arg1 =
reinterpret_cast< Agedge_t *
>(argp1);
4735 arg2 =
reinterpret_cast< Agsym_t *
>(argp2);
4736 result = (
char *)
getv(arg1,arg2);
4746 PyObject *argv[3] = {
4836 " Possible C/C++ prototypes are:\n"
4837 " getv(Agraph_t *,char *)\n"
4838 " getv(Agnode_t *,char *)\n"
4839 " getv(Agedge_t *,char *)\n"
4840 " getv(Agraph_t *,Agsym_t *)\n"
4841 " getv(Agnode_t *,Agsym_t *)\n"
4842 " getv(Agedge_t *,Agsym_t *)\n");
4848 PyObject *resultobj = 0;
4855 if ((nobjs < 1) || (nobjs > 1))
SWIG_fail;
4860 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
4861 result = (
char *)
nameof(arg1);
4870 PyObject *resultobj = 0;
4877 if ((nobjs < 1) || (nobjs > 1))
SWIG_fail;
4882 arg1 =
reinterpret_cast< Agnode_t *
>(argp1);
4883 result = (
char *)
nameof(arg1);
4892 PyObject *resultobj = 0;
4899 if ((nobjs < 1) || (nobjs > 1))
SWIG_fail;
4904 arg1 =
reinterpret_cast< Agsym_t *
>(argp1);
4905 result = (
char *)
nameof(arg1);
4915 PyObject *argv[2] = {
4951 " Possible C/C++ prototypes are:\n"
4952 " nameof(Agraph_t *)\n"
4953 " nameof(Agnode_t *)\n"
4954 " nameof(Agsym_t *)\n");
4960 PyObject *resultobj = 0;
4962 char *arg2 = (
char *) 0 ;
4968 PyObject *swig_obj[2] ;
4977 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
4982 arg2 =
reinterpret_cast< char *
>(buf2);
4994 PyObject *resultobj = 0;
4996 char *arg2 = (
char *) 0 ;
5002 PyObject *swig_obj[2] ;
5011 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
5016 arg2 =
reinterpret_cast< char *
>(buf2);
5028 PyObject *resultobj = 0;
5035 PyObject *swig_obj[2] ;
5044 arg1 =
reinterpret_cast< Agnode_t *
>(argp1);
5049 arg2 =
reinterpret_cast< Agnode_t *
>(argp2);
5059 PyObject *resultobj = 0;
5061 char *arg2 = (
char *) 0 ;
5070 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
5075 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
5080 arg2 =
reinterpret_cast< char *
>(buf2);
5092 PyObject *resultobj = 0;
5094 char *arg2 = (
char *) 0 ;
5103 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
5108 arg1 =
reinterpret_cast< Agnode_t *
>(argp1);
5113 arg2 =
reinterpret_cast< char *
>(buf2);
5125 PyObject *resultobj = 0;
5127 char *arg2 = (
char *) 0 ;
5136 if ((nobjs < 2) || (nobjs > 2))
SWIG_fail;
5141 arg1 =
reinterpret_cast< Agedge_t *
>(argp1);
5146 arg2 =
reinterpret_cast< char *
>(buf2);
5159 PyObject *argv[3] = {
5207 " Possible C/C++ prototypes are:\n"
5208 " findattr(Agraph_t *,char *)\n"
5209 " findattr(Agnode_t *,char *)\n"
5210 " findattr(Agedge_t *,char *)\n");
5216 PyObject *resultobj = 0;
5220 PyObject *swig_obj[1] ;
5230 arg1 =
reinterpret_cast< Agedge_t *
>(argp1);
5240 PyObject *resultobj = 0;
5244 PyObject *swig_obj[1] ;
5254 arg1 =
reinterpret_cast< Agedge_t *
>(argp1);
5264 PyObject *resultobj = 0;
5271 if ((nobjs < 1) || (nobjs > 1))
SWIG_fail;
5276 arg1 =
reinterpret_cast< Agraph_t *
>(argp1);
5286 PyObject *resultobj = 0;
5293 if ((nobjs < 1) || (nobjs > 1))
SWIG_fail;
5298 arg1 =
reinterpret_cast< Agedge_t *
>(argp1);