Google Git Google Git
Sign in
fuchsia/third_party/swig/725bc081da170662b194ca1ff5e7e75144bc0760/./Lib/python/pyrun.swg
blob: 1db1d3c11c40b9cb0bbc91335dfc9cdf04e65bfc [file]
/* -----------------------------------------------------------------------------
* pyrun.swg
*
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* type checking.
*
* ----------------------------------------------------------------------------- */
#if PY_VERSION_HEX < 0x03050000
# error "This version of SWIG only supports Python >= 3.5"
#endif
/* Common SWIG API */
/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif
#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype int
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
/* Runtime API */
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
#define SWIG_fail goto fail
/* Runtime API implementation */
/* Error manipulation */
SWIGINTERN void
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetObject(errtype, obj);
SWIG_Py_DECREF(obj);
SWIG_PYTHON_THREAD_END_BLOCK;
}
SWIGINTERN void
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
PyErr_SetString(errtype, msg);
SWIG_PYTHON_THREAD_END_BLOCK;
}
#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
/* Set a constant value */
#if defined(SWIGPYTHON_BUILTIN)
SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
PyObject *s = PyUnicode_InternFromString(key);
PyList_Append(seq, s);
SWIG_Py_DECREF(s);
}
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
SWIG_Py_DECREF(obj);
if (public_interface)
SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}
#else
SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
PyDict_SetItemString(d, name, obj);
SWIG_Py_DECREF(obj);
}
#endif
/* SWIG runtime data Python module */
static PyObject *Swig_runtime_data_module_global = NULL;
/* Create/obtain the single swig_runtime_data module which is used across different SWIG generated modules */
SWIGINTERN PyObject *
SWIG_runtime_data_module(void) {
if (!Swig_runtime_data_module_global) {
#if (PY_VERSION_HEX >= 0x030d0000) && (!defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d0000)
/* free-threading note: the GIL is always enabled when this function is first called
by SWIG_init, so there's no risk of race conditions */
Swig_runtime_data_module_global = PyImport_AddModuleRef(SWIG_RUNTIME_MODULE);
#else
Swig_runtime_data_module_global = PyImport_AddModule(SWIG_RUNTIME_MODULE);
SWIG_Py_XINCREF(Swig_runtime_data_module_global);
#endif
}
assert(Swig_runtime_data_module_global);
return Swig_runtime_data_module_global;
}
/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj, int is_void) {
if (!result) {
result = obj;
} else if (result == Py_None && is_void) {
SWIG_Py_DECREF(result);
result = obj;
} else {
if (!PyList_Check(result)) {
PyObject *o2 = result;
result = PyList_New(1);
if (result) {
PyList_SET_ITEM(result, 0, o2);
} else {
SWIG_Py_DECREF(obj);
return o2;
}
}
PyList_Append(result,obj);
SWIG_Py_DECREF(obj);
}
return result;
}
/* Unpack the argument tuple */
SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
if (!args) {
if (!min && !max) {
return 1;
} else {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
name, (min == max ? "" : "at least "), (int)min);
return 0;
}
}
if (!PyTuple_Check(args)) {
if (min <= 1 && max >= 1) {
Py_ssize_t i;
objs[0] = args;
for (i = 1; i < max; ++i) {
objs[i] = 0;
}
return 2;
}
PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
return 0;
} else {
Py_ssize_t l = PyTuple_GET_SIZE(args);
if (l < min) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at least "), (int)min, (int)l);
return 0;
} else if (l > max) {
PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
name, (min == max ? "" : "at most "), (int)max, (int)l);
return 0;
} else {
Py_ssize_t i;
for (i = 0; i < l; ++i) {
objs[i] = PyTuple_GET_ITEM(args, i);
}
for (; l < max; ++l) {
objs[l] = 0;
}
return i + 1;
}
}
}
SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
int no_kwargs = 1;
if (kwargs) {
assert(PyDict_Check(kwargs));
if (PyDict_Size(kwargs) > 0) {
PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
no_kwargs = 0;
}
}
return no_kwargs;
}
/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
/*
Helper for static pointer initialization for both C and C++ code, for example
static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var) var
#else
#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
#endif
#ifdef __cplusplus
extern "C" {
#endif
/* Python-specific SWIG API */
#define SWIG_newvarlink() SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
/* -----------------------------------------------------------------------------
* global variable support code.
* ----------------------------------------------------------------------------- */
typedef struct swig_globalvar {
char *name; /* Name of global variable */
PyObject *(*get_attr)(void); /* Return the current value */
int (*set_attr)(PyObject *); /* Set the value */
struct swig_globalvar *next;
} swig_globalvar;
typedef struct swig_varlinkobject {
PyObject_HEAD
swig_globalvar *vars;
} swig_varlinkobject;
SWIGINTERN PyObject *
SwigVarLink_repr(PyObject *SWIGUNUSEDPARM(v)) {
return PyUnicode_InternFromString("<Swig global variables>");
}
SWIGINTERN PyObject *
SwigVarLink_str(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
PyObject *str = PyUnicode_InternFromString("(");
PyObject *tail;
PyObject *joined;
swig_globalvar *var;
for (var = v->vars; var; var=var->next) {
tail = PyUnicode_FromString(var->name);
joined = PyUnicode_Concat(str, tail);
SWIG_Py_DECREF(str);
SWIG_Py_DECREF(tail);
str = joined;
if (var->next) {
tail = PyUnicode_InternFromString(", ");
joined = PyUnicode_Concat(str, tail);
SWIG_Py_DECREF(str);
SWIG_Py_DECREF(tail);
str = joined;
}
}
tail = PyUnicode_InternFromString(")");
joined = PyUnicode_Concat(str, tail);
SWIG_Py_DECREF(str);
SWIG_Py_DECREF(tail);
str = joined;
return str;
}
SWIGINTERN void
SwigVarLink_dealloc(PyObject *o) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
swig_globalvar *var = v->vars;
while (var) {
swig_globalvar *n = var->next;
free(var->name);
free(var);
var = n;
}
}
SWIGINTERN PyObject *
SwigVarLink_getattr(PyObject *o, char *n) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
PyObject *res = NULL;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->get_attr)();
break;
}
var = var->next;
}
if (res == NULL && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN int
SwigVarLink_setattr(PyObject *o, char *n, PyObject *p) {
swig_varlinkobject *v = (swig_varlinkobject *) o;
int res = 1;
swig_globalvar *var = v->vars;
while (var) {
if (strcmp(var->name,n) == 0) {
res = (*var->set_attr)(p);
break;
}
var = var->next;
}
if (res == 1 && !PyErr_Occurred()) {
PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
}
return res;
}
SWIGINTERN PyTypeObject*
SwigVarLink_TypeOnce(void) {
static char SwigVarLink_doc[] = "Swig variable link object";
#ifndef SWIG_HEAPTYPES
static PyTypeObject varlink_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
PyVarObject_HEAD_INIT(NULL, 0)
SWIG_RUNTIME_MODULE ".SwigVarLink", /* tp_name */
sizeof(swig_varlinkobject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor) SwigVarLink_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
(getattrfunc) SwigVarLink_getattr, /* tp_getattr */
(setattrfunc) SwigVarLink_setattr, /* tp_setattr */
0, /* tp_compare */
(reprfunc) SwigVarLink_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
(reprfunc) SwigVarLink_str, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
SwigVarLink_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
0, /* tp_finalize */
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
0, /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
0, /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
PyObject *runtime_data_module = SWIG_runtime_data_module();
varlink_type = tmp;
type_init = 1;
if (PyType_Ready(&varlink_type) < 0)
return NULL;
if (PyModule_AddObject(runtime_data_module, "SwigVarLink", (PyObject *)&varlink_type) == 0)
SWIG_Py_INCREF((PyObject *)&varlink_type);
}
return &varlink_type;
#else
PyType_Slot slots[] = {
{ Py_tp_dealloc, (void *)SwigVarLink_dealloc },
{ Py_tp_repr, (void *)SwigVarLink_repr },
{ Py_tp_getattr, (void *)SwigVarLink_getattr },
{ Py_tp_setattr, (void *)SwigVarLink_setattr },
{ Py_tp_str, (void *)SwigVarLink_str },
{ Py_tp_doc, (void *)SwigVarLink_doc },
{ 0, NULL }
};
PyType_Spec spec = {
SWIG_RUNTIME_MODULE ".SwigVarLink",
sizeof(swig_varlinkobject),
0,
Py_TPFLAGS_DEFAULT,
slots
};
PyObject *pytype = PyType_FromSpec(&spec);
PyObject *runtime_data_module = SWIG_runtime_data_module();
if (pytype && PyModule_AddObject(runtime_data_module, "SwigVarLink", pytype) == 0)
SWIG_Py_INCREF(pytype);
return (PyTypeObject *)pytype;
#endif
}
SWIGRUNTIME PyTypeObject*
SwigVarLink_Type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigVarLink_TypeOnce();
return type;
}
/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
swig_varlinkobject *result = PyObject_New(swig_varlinkobject, SwigVarLink_Type());
if (result) {
result->vars = 0;
}
return ((PyObject*) result);
}
SWIGINTERN void
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v = (swig_varlinkobject *) p;
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
if (gv) {
size_t size = strlen(name)+1;
gv->name = (char *)malloc(size);
if (gv->name) {
memcpy(gv->name, name, size);
gv->get_attr = get_attr;
gv->set_attr = set_attr;
gv->next = v->vars;
}
}
v->vars = gv;
}
static PyObject *Swig_Globals_global = NULL;
SWIGINTERN PyObject *
SWIG_globals(void) {
if (Swig_Globals_global == NULL) {
Swig_Globals_global = SWIG_newvarlink();
}
return Swig_Globals_global;
}
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* Pointer declarations
* ----------------------------------------------------------------------------- */
/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
#ifdef __cplusplus
extern "C" {
#endif
/* The python void return value */
SWIGRUNTIMEINLINE PyObject *
SWIG_Py_Void(void)
{
PyObject *none = Py_None;
SWIG_Py_INCREF(none);
return none;
}
/* SwigPyClientData */
typedef struct {
PyObject *klass;
PyObject *newraw;
PyObject *newargs;
PyObject *destroy;
int delargs;
int implicitconv;
PyTypeObject *pytype;
} SwigPyClientData;
SWIGRUNTIMEINLINE int
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
int fail = data ? data->implicitconv : 0;
if (fail)
PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
return fail;
}
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
PyObject *klass = data ? data->klass : 0;
return (klass ? klass : PyExc_RuntimeError);
}
SWIGRUNTIME SwigPyClientData *
SwigPyClientData_New(PyObject* obj)
{
if (!obj) {
return 0;
} else {
SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
/* the klass element */
data->klass = obj;
SWIG_Py_INCREF(data->klass);
/* the newraw method and newargs arguments used to create a new raw instance */
if (PyObject_IsInstance(obj, (PyObject *)&PyType_Type)) {
data->newraw = 0;
SWIG_Py_INCREF(obj);
data->newargs = obj;
} else {
data->newraw = PyObject_GetAttrString(data->klass, "__new__");
if (data->newraw) {
data->newargs = PyTuple_New(1);
if (data->newargs) {
SWIG_Py_INCREF(obj);
PyTuple_SET_ITEM(data->newargs, 0, obj);
} else {
SWIG_Py_DECREF(data->newraw);
SWIG_Py_DECREF(data->klass);
free(data);
return 0;
}
} else {
SWIG_Py_INCREF(obj);
data->newargs = obj;
}
}
/* the destroy method, aka as the C++ delete method */
data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
if (PyErr_Occurred()) {
PyErr_Clear();
data->destroy = 0;
}
if (data->destroy) {
data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
} else {
data->delargs = 0;
}
data->implicitconv = 0;
data->pytype = 0;
return data;
}
}
SWIGRUNTIME void
SwigPyClientData_Del(SwigPyClientData *data)
{
SWIG_Py_XDECREF(data->klass);
SWIG_Py_XDECREF(data->newraw);
SWIG_Py_XDECREF(data->newargs);
SWIG_Py_XDECREF(data->destroy);
free(data);
}
/* =============== SwigPyObject =====================*/
typedef struct {
PyObject_HEAD
void *ptr;
swig_type_info *ty;
int own;
PyObject *next;
PyObject *swigdict;
PyObject *weakreflist;
} SwigPyObject;
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
if (!sobj->swigdict)
sobj->swigdict = PyDict_New();
SWIG_Py_XINCREF(sobj->swigdict);
return sobj->swigdict;
}
#endif
SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
return PyLong_FromVoidPtr(v->ptr);
}
SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
PyObject *res = NULL;
PyObject *args = PyTuple_New(1);
if (args) {
PyObject *val = SwigPyObject_long(v);
if (val) {
PyObject *ofmt;
PyTuple_SET_ITEM(args, 0, val);
ofmt = PyUnicode_FromString(fmt);
if (ofmt) {
res = PyUnicode_Format(ofmt,args);
SWIG_Py_DECREF(ofmt);
}
}
SWIG_Py_DECREF(args);
}
return res;
}
SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
return SwigPyObject_format("%o",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
return SwigPyObject_format("%x",v);
}
SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
const char *name = SWIG_TypePrettyName(v->ty);
PyObject *repr = PyUnicode_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
if (repr && v->next) {
PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
if (nrep) {
PyObject *joined = PyUnicode_Concat(repr, nrep);
SWIG_Py_DECREF(repr);
SWIG_Py_DECREF(nrep);
repr = joined;
} else {
SWIG_Py_DECREF(repr);
repr = NULL;
}
}
return repr;
}
/* We need a version taking two PyObject* parameters so it's a valid
* PyCFunction to use in SwigPyObject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
return SwigPyObject_repr((SwigPyObject*)v);
}
SWIGRUNTIME int
SwigPyObject_compare(PyObject *v, PyObject *w)
{
/* tp_compare is only called when both objects have the same type, so
* the casts are guaranteed to be ok. */
void *i = ((SwigPyObject *)v)->ptr;
void *j = ((SwigPyObject *)w)->ptr;
return (i < j) ? -1 : ((i > j) ? 1 : 0);
}
SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *);
/* Rich comparison support */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(PyObject *v, PyObject *w, int op)
{
PyObject* res = NULL;
if (!PyErr_Occurred()) {
/* Per https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_richcompare
* the first argument is guaranteed to be an instance of SwigPyObject, but the
* second is not, so we typecheck that one. */
if ((op != Py_EQ && op != Py_NE) || !SwigPyObject_Check(w)) {
SWIG_Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
}
return res;
}
SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_Type(void) {
SwigPyClientData *cd;
assert(SwigPyObject_stype);
cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
assert(cd);
assert(cd->pytype);
return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_Type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
return type;
}
#endif
SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
PyTypeObject *target_tp = SwigPyObject_Type();
PyTypeObject *op_type = Py_TYPE(op);
#ifdef SWIGPYTHON_BUILTIN
/* Only builtin types have SwigPyObject as a base type */
return PyType_IsSubtype(op_type, target_tp);
#else
/* Check for an exact match to SwigPyObject */
if (op_type == target_tp) {
return 1;
} else {
/* Fallback for multiple modules */
int cmp;
PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
if (!tpname)
return 0;
cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyObject");
SWIG_Py_DECREF(tpname);
return cmp == 0;
}
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
static PyObject* Swig_Capsule_global = NULL;
SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
SwigPyObject *sobj = (SwigPyObject *) v;
PyObject *next = sobj->next;
if (sobj->own == SWIG_POINTER_OWN) {
swig_type_info *ty = sobj->ty;
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
PyObject *destroy = data ? data->destroy : 0;
if (destroy) {
/* destroy is always a VARARGS method */
PyObject *res;
/* PyObject_CallFunction() has the potential to silently drop
the active exception. In cases of unnamed temporary
variable or where we just finished iterating over a generator
StopIteration will be active right now, and this needs to
remain true upon return from SwigPyObject_dealloc. So save
and restore. */
PyObject *type = NULL, *value = NULL, *traceback = NULL;
PyErr_Fetch(&type, &value, &traceback);
if (data->delargs) {
/* we need to create a temporary object to carry the destroy operation */
PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
if (tmp) {
res = SWIG_Python_CallFunctor(destroy, tmp);
} else {
res = 0;
}
SWIG_Py_XDECREF(tmp);
} else {
PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
PyObject *mself = PyCFunction_GET_SELF(destroy);
res = ((*meth)(mself, v));
}
if (!res)
PyErr_WriteUnraisable(destroy);
PyErr_Restore(type, value, traceback);
SWIG_Py_XDECREF(res);
}
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
else {
const char *name = SWIG_TypePrettyName(ty);
printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
}
#endif
SWIG_Py_XDECREF(Swig_Capsule_global);
}
SWIG_Py_XDECREF(next);
SWIG_Py_XDECREF(sobj->swigdict);
PyObject_Free(v);
}
SWIGRUNTIME PyObject*
SwigPyObject_append(PyObject* v, PyObject* next)
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (!SwigPyObject_Check(next)) {
PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
return NULL;
}
((SwigPyObject *)next)->next = sobj->next;
sobj->next = next;
SWIG_Py_INCREF(next);
return SWIG_Py_Void();
}
SWIGRUNTIME PyObject*
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *) v;
if (sobj->next) {
SWIG_Py_INCREF(sobj->next);
return sobj->next;
} else {
return SWIG_Py_Void();
}
}
SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = 0;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
SwigPyObject *sobj = (SwigPyObject *)v;
sobj->own = SWIG_POINTER_OWN;
return SWIG_Py_Void();
}
SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
PyObject *val = 0;
if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
return NULL;
} else {
SwigPyObject *sobj = (SwigPyObject *)v;
PyObject *obj = PyBool_FromLong(sobj->own);
if (val) {
if (PyObject_IsTrue(val)) {
SWIG_Py_DECREF(SwigPyObject_acquire(v,args));
} else {
SWIG_Py_DECREF(SwigPyObject_disown(v,args));
}
}
return obj;
}
}
static PyMethodDef
SwigPyObject_methods[] = {
{"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"},
{"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"},
{"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"},
{"append", SwigPyObject_append, METH_O, "appends another 'this' object"},
{"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"},
{"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"},
{0, 0, 0, 0}
};
SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
static char SwigPyObject_doc[] = "Swig object holding a C/C++ pointer";
#ifndef SWIG_HEAPTYPES
static PyNumberMethods SwigPyObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
(binaryfunc)0, /*nb_remainder*/
(binaryfunc)0, /*nb_divmod*/
(ternaryfunc)0,/*nb_power*/
(unaryfunc)0, /*nb_negative*/
(unaryfunc)0, /*nb_positive*/
(unaryfunc)0, /*nb_absolute*/
(inquiry)0, /*nb_bool*/
0, /*nb_invert*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
(unaryfunc)SwigPyObject_long, /*nb_int*/
0, /*nb_reserved*/
(unaryfunc)0, /*nb_float*/
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
};
static PyTypeObject swigpyobject_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
PyVarObject_HEAD_INIT(NULL, 0)
SWIG_RUNTIME_MODULE ".SwigPyObject", /* tp_name */
sizeof(SwigPyObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyObject_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
(reprfunc)SwigPyObject_repr, /* tp_repr */
&SwigPyObject_as_number, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
0, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
SwigPyObject_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
offsetof(SwigPyObject, weakreflist), /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
SwigPyObject_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
0, /* tp_finalize */
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
0, /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
0, /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
PyObject *runtime_data_module = SWIG_runtime_data_module();
swigpyobject_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpyobject_type) != 0)
return NULL;
if (PyModule_AddObject(runtime_data_module, "SwigPyObject", (PyObject *)&swigpyobject_type) == 0)
SWIG_Py_INCREF((PyObject *)&swigpyobject_type);
}
return &swigpyobject_type;
#else
static PyMemberDef SwigPyObject_members[] = {
{ (char *)"__dictoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, swigdict), Py_READONLY, NULL },
{ (char *)"__weaklistoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, weakreflist), Py_READONLY, NULL },
{ NULL, 0, 0, 0, NULL }
};
PyType_Slot slots[] = {
{ Py_tp_dealloc, (void *)SwigPyObject_dealloc },
{ Py_tp_repr, (void *)SwigPyObject_repr },
{ Py_tp_getattro, (void *)PyObject_GenericGetAttr },
{ Py_tp_doc, (void *)SwigPyObject_doc },
{ Py_tp_richcompare, (void *)SwigPyObject_richcompare },
{ Py_tp_methods, (void *)SwigPyObject_methods },
{ Py_nb_int, (void *)SwigPyObject_long },
{ Py_tp_members, (void *)SwigPyObject_members },
{ 0, NULL }
};
PyType_Spec spec = {
SWIG_RUNTIME_MODULE ".SwigPyObject",
sizeof(SwigPyObject),
0,
Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
slots
};
PyObject *pytype = PyType_FromSpec(&spec);
PyObject *runtime_data_module = SWIG_runtime_data_module();
#if !defined(Py_LIMITED_API)
/* While this __dictoffset__ is only used with the builtin wrappers, SwigPyObject ought to be
identical when created for use by proxy class wrappers in case it is shared across multiple modules. */
#if PY_VERSION_HEX < 0x03090000
/* Workaround as __dictoffset__ and __weaklistoffset__ above are only supported from python-3.9 */
if (pytype) {
((PyTypeObject *)pytype)->tp_dictoffset = offsetof(SwigPyObject, swigdict);
((PyTypeObject *)pytype)->tp_weaklistoffset = offsetof(SwigPyObject, weakreflist);
}
#endif
#endif
if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyObject", pytype) == 0)
SWIG_Py_INCREF(pytype);
return (PyTypeObject *)pytype;
#endif
}
SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_Type());
if (sobj) {
sobj->ptr = ptr;
sobj->ty = ty;
sobj->own = own;
sobj->next = 0;
sobj->swigdict = 0;
sobj->weakreflist = 0;
if (own == SWIG_POINTER_OWN) {
/* Obtain a reference to the Python capsule wrapping the module information, so that the
* module information is correctly destroyed after all SWIG python objects have been freed
* by the GC (and corresponding destructors invoked) */
SWIG_Py_XINCREF(Swig_Capsule_global);
}
}
return (PyObject *)sobj;
}
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
typedef struct {
PyObject_HEAD
void *pack;
swig_type_info *ty;
size_t size;
} SwigPyPacked;
SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return PyUnicode_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
} else {
return PyUnicode_FromFormat("<Swig Packed %s>", v->ty->name);
}
}
SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return PyUnicode_FromFormat("%s%s", result, v->ty->name);
} else {
return PyUnicode_FromString(v->ty->name);
}
}
SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
size_t i = v->size;
size_t j = w->size;
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}
SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
SWIGRUNTIME PyTypeObject*
SwigPyPacked_Type(void) {
static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
return type;
}
SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
PyTypeObject *target_tp = SwigPyPacked_Type();
PyTypeObject *op_type = Py_TYPE(op);
/* Check for an exact match to SwigPyPacked */
if (op_type == target_tp) {
return 1;
} else {
/* Fallback for multiple modules */
int cmp;
PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
if (!tpname)
return 0;
cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyPacked");
SWIG_Py_DECREF(tpname);
return cmp == 0;
}
}
SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
if (SwigPyPacked_Check(v)) {
SwigPyPacked *sobj = (SwigPyPacked *) v;
free(sobj->pack);
}
PyObject_Free(v);
}
SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
static char SwigPyPacked_doc[] = "Swig object holding a C/C++ function pointer";
#ifndef SWIG_HEAPTYPES
static PyTypeObject swigpypacked_type;
static int type_init = 0;
if (!type_init) {
const PyTypeObject tmp = {
PyVarObject_HEAD_INIT(NULL, 0)
SWIG_RUNTIME_MODULE ".SwigPyPacked", /* tp_name */
sizeof(SwigPyPacked), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
(printfunc)0, /* tp_print */
#else
(Py_ssize_t)0, /* tp_vectorcall_offset */
#endif
(getattrfunc)0, /* tp_getattr */
(setattrfunc)0, /* tp_setattr */
0, /* tp_reserved in 3.0.1 */
(reprfunc)SwigPyPacked_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
(hashfunc)0, /* tp_hash */
(ternaryfunc)0, /* tp_call */
(reprfunc)SwigPyPacked_str, /* tp_str */
PyObject_GenericGetAttr, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
SwigPyPacked_doc, /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
0, /* tp_init */
0, /* tp_alloc */
0, /* tp_new */
0, /* tp_free */
0, /* tp_is_gc */
0, /* tp_bases */
0, /* tp_mro */
0, /* tp_cache */
0, /* tp_subclasses */
0, /* tp_weaklist */
0, /* tp_del */
0, /* tp_version_tag */
0, /* tp_finalize */
#if PY_VERSION_HEX >= 0x03080000
0, /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
0, /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
0, /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
0, /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
0, /* tp_allocs */
0, /* tp_frees */
0, /* tp_maxalloc */
0, /* tp_prev */
0 /* tp_next */
#endif
};
PyObject *runtime_data_module = SWIG_runtime_data_module();
swigpypacked_type = tmp;
type_init = 1;
if (PyType_Ready(&swigpypacked_type) != 0)
return NULL;
if (PyModule_AddObject(runtime_data_module, "SwigPyPacked", (PyObject *)&swigpypacked_type) == 0)
SWIG_Py_INCREF((PyObject *)&swigpypacked_type);
}
return &swigpypacked_type;
#else
PyType_Slot slots[] = {
{ Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
{ Py_tp_repr, (void *)SwigPyPacked_repr },
{ Py_tp_str, (void *)SwigPyPacked_str },
{ Py_tp_getattro, (void *)PyObject_GenericGetAttr },
{ Py_tp_doc, (void *)SwigPyPacked_doc },
{ 0, NULL }
};
PyType_Spec spec = {
SWIG_RUNTIME_MODULE ".SwigPyPacked",
sizeof(SwigPyPacked),
0,
Py_TPFLAGS_DEFAULT,
slots
};
PyObject *pytype = PyType_FromSpec(&spec);
PyObject *runtime_data_module = SWIG_runtime_data_module();
if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyPacked", pytype) == 0)
SWIG_Py_INCREF(pytype);
return (PyTypeObject *)pytype;
#endif
}
SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_Type());
if (sobj) {
void *pack = malloc(size);
if (pack) {
memcpy(pack, ptr, size);
sobj->pack = pack;
sobj->ty = ty;
sobj->size = size;
} else {
PyObject_Free((PyObject *)sobj);
sobj = 0;
}
}
return (PyObject *) sobj;
}
SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
if (SwigPyPacked_Check(obj)) {
SwigPyPacked *sobj = (SwigPyPacked *)obj;
if (sobj->size != size) return 0;
memcpy(ptr, sobj->pack, size);
return sobj->ty;
} else {
return 0;
}
}
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
static PyObject *Swig_This_global = NULL;
SWIGRUNTIME PyObject *
SWIG_This(void)
{
if (Swig_This_global == NULL)
Swig_This_global = PyUnicode_FromString("this");
return Swig_This_global;
}
/* Returns a borrowed reference to the 'this' object */
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
PyObject *obj;
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
#ifdef SWIGPYTHON_BUILTIN
(void)obj;
if (PyWeakref_CheckProxy(pyobj)) {
#if PY_VERSION_HEX >= 0x030d0000
if (PyWeakref_GetRef(pyobj, &pyobj) > 0)
Py_DECREF(pyobj);
else
pyobj = NULL;
#else
pyobj = PyWeakref_GetObject(pyobj);
#endif
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
return NULL;
#else
obj = 0;
obj = PyObject_GetAttr(pyobj, SWIG_This());
if (obj) {
SWIG_Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
#endif
}
/* Acquire a pointer value */
SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
if (own == SWIG_POINTER_OWN) {
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
if (sobj) {
int oldown = sobj->own;
sobj->own = own;
return oldown;
}
}
return 0;
}
/* Convert a pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
int res;
SwigPyObject *sobj;
int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
if (!obj)
return SWIG_ERROR;
if (obj == Py_None && !implicit_conv) {
if (ptr)
*ptr = 0;
return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
}
res = SWIG_ERROR;
sobj = SWIG_Python_GetSwigThis(obj);
if (own)
*own = 0;
while (sobj) {
void *vptr = sobj->ptr;
if (ty) {
swig_type_info *to = sobj->ty;
if (to == ty) {
/* no type cast needed */
if (ptr) *ptr = vptr;
break;
} else {
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) {
sobj = (SwigPyObject *)sobj->next;
} else {
if (ptr) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
if (newmemory == SWIG_CAST_NEW_MEMORY) {
assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
if (own)
*own = *own | SWIG_CAST_NEW_MEMORY;
}
}
break;
}
}
} else {
if (ptr) *ptr = vptr;
break;
}
}
if (sobj) {
if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
res = SWIG_ERROR_RELEASE_NOT_OWNED;
} else {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN) {
sobj->own = 0;
}
if (flags & SWIG_POINTER_CLEAR) {
sobj->ptr = 0;
}
res = SWIG_OK;
}
} else {
if (implicit_conv) {
SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
if (data && !data->implicitconv) {
PyObject *klass = data->klass;
if (klass) {
PyObject *impconv;
data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
impconv = SWIG_Python_CallFunctor(klass, obj);
data->implicitconv = 0;
if (PyErr_Occurred()) {
PyErr_Clear();
impconv = 0;
}
if (impconv) {
SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
if (iobj) {
void *vptr;
res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
if (SWIG_IsOK(res)) {
if (ptr) {
*ptr = vptr;
/* transfer the ownership to 'ptr' */
iobj->own = 0;
res = SWIG_AddCast(res);
res = SWIG_AddNewMask(res);
} else {
res = SWIG_AddCast(res);
}
}
}
SWIG_Py_DECREF(impconv);
}
}
}
if (!SWIG_IsOK(res) && obj == Py_None) {
if (ptr)
*ptr = 0;
if (PyErr_Occurred())
PyErr_Clear();
res = SWIG_OK;
}
}
}
return res;
}
/* Convert a function ptr value */
SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
if (!PyCFunction_Check(obj)) {
return SWIG_ConvertPtr(obj, ptr, ty, 0);
} else {
void *vptr = 0;
swig_cast_info *tc;
/* here we get the method pointer for callbacks */
#ifndef Py_LIMITED_API
const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
#else
PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
PyObject *bytes = NULL;
const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
#endif
const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
if (desc)
desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
#ifdef Py_LIMITED_API
SWIG_Py_XDECREF(bytes);
SWIG_Py_XDECREF(pystr_doc);
#endif
if (!desc)
return SWIG_ERROR;
tc = SWIG_TypeCheck(desc,ty);
if (tc) {
int newmemory = 0;
*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
assert(!newmemory); /* newmemory handling not yet implemented */
} else {
return SWIG_ERROR;
}
return SWIG_OK;
}
}
/* Convert a packed pointer value */
SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
if (!to) return SWIG_ERROR;
if (ty) {
if (to != ty) {
/* check type cast? */
swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
if (!tc) return SWIG_ERROR;
}
}
return SWIG_OK;
}
/* -----------------------------------------------------------------------------
* Create a new pointer object
* ----------------------------------------------------------------------------- */
/*
Create a new instance object, without calling __init__, and set the
'this' attribute.
*/
SWIGRUNTIME PyObject*
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
PyObject *inst = 0;
PyObject *newraw = data->newraw;
if (newraw) {
inst = PyObject_Call(newraw, data->newargs, NULL);
if (inst) {
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
SWIG_Py_DECREF(inst);
inst = 0;
}
}
} else {
PyObject *empty_args = PyTuple_New(0);
if (empty_args) {
PyObject *empty_kwargs = PyDict_New();
if (empty_kwargs) {
#ifndef Py_LIMITED_API
newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
#else
newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
#endif
inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
SWIG_Py_DECREF(empty_kwargs);
if (inst) {
if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
SWIG_Py_DECREF(inst);
inst = 0;
} else {
PyType_Modified(Py_TYPE(inst));
}
}
}
SWIG_Py_DECREF(empty_args);
}
}
return inst;
}
SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
return PyObject_SetAttr(inst, SWIG_This(), swig_this);
}
SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
PyObject *obj[2];
if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
return NULL;
} else {
SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
if (sthis) {
SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
} else {
if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
return NULL;
}
return SWIG_Py_Void();
}
}
/* Create a new pointer object */
SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
SwigPyClientData *clientdata;
PyObject * robj;
int own;
if (!ptr)
return SWIG_Py_Void();
clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
if (clientdata && clientdata->pytype) {
SwigPyObject *newobj;
if (flags & SWIG_BUILTIN_TP_INIT) {
newobj = (SwigPyObject*) self;
if (newobj->ptr) {
#ifndef Py_LIMITED_API
allocfunc alloc = clientdata->pytype->tp_alloc;
#else
allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
#endif
PyObject *next_self = alloc(clientdata->pytype, 0);
while (newobj->next)
newobj = (SwigPyObject *) newobj->next;
newobj->next = next_self;
newobj = (SwigPyObject *)next_self;
newobj->swigdict = 0;
newobj->weakreflist = 0;
}
} else {
newobj = PyObject_New(SwigPyObject, clientdata->pytype);
if (newobj) {
newobj->swigdict = 0;
newobj->weakreflist = 0;
}
}
if (newobj) {
newobj->ptr = ptr;
newobj->ty = type;
newobj->own = own;
newobj->next = 0;
return (PyObject*) newobj;
}
return SWIG_Py_Void();
}
assert(!(flags & SWIG_BUILTIN_TP_INIT));
robj = SwigPyObject_New(ptr, type, own);
if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
SWIG_Py_DECREF(robj);
robj = inst;
}
return robj;
}
/* Create a new packed object */
SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}
/* -----------------------------------------------------------------------------*
* Get type list
* -----------------------------------------------------------------------------*/
#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif
static PyObject *Swig_TypeCache_global = NULL;
/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
if (Swig_TypeCache_global == NULL) {
Swig_TypeCache_global = PyDict_New();
}
return Swig_TypeCache_global;
}
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
static void *type_pointer = (void *)0;
/* first check if module already created */
if (!type_pointer) {
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
}
#else
void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
if (PyErr_Occurred()) {
PyErr_Clear();
type_pointer = (void *)0;
}
#endif
return (swig_module_info *) type_pointer;
}
#if defined(SWIG_REFCNT_DEBUG)
#define SWIG_PYOBJ_REFCNT(OBJ) fprintf(stdout, "" #OBJ " count %ld\n", (OBJ ? Py_REFCNT(OBJ) : 0))
#else
#define SWIG_PYOBJ_REFCNT(OBJ)
#endif
static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */
SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
swig_type_info **types = swig_module->types;
size_t i;
if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
return;
for (i = 0; i < swig_module->size; ++i) {
swig_type_info *ty = types[i];
if (ty->owndata) {
SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
ty->clientdata = 0;
if (data) SwigPyClientData_Del(data);
}
}
SWIG_PYOBJ_REFCNT(Swig_This_global);
SWIG_Py_XDECREF(Swig_This_global);
Swig_This_global = NULL;
SWIG_PYOBJ_REFCNT(Swig_Globals_global);
SWIG_Py_XDECREF(Swig_Globals_global);
Swig_Globals_global = NULL;
SWIG_PYOBJ_REFCNT(Swig_TypeCache_global);
SWIG_Py_XDECREF(Swig_TypeCache_global);
Swig_TypeCache_global = NULL;
SWIG_PYOBJ_REFCNT(Swig_Capsule_global);
Swig_Capsule_global = NULL;
SWIG_PYOBJ_REFCNT(Swig_runtime_data_module_global);
SWIG_Py_XDECREF(Swig_runtime_data_module_global);
Swig_runtime_data_module_global = NULL;
}
SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
PyObject *runtime_data_module = SWIG_runtime_data_module();
PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
if (pointer && runtime_data_module) {
if (PyModule_AddObject(runtime_data_module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
++interpreter_counter;
Swig_Capsule_global = pointer;
} else {
SWIG_Py_DECREF(pointer);
}
} else {
SWIG_Py_XDECREF(pointer);
}
}
SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
swig_type_info *descriptor;
PyObject *cache = SWIG_Python_TypeCache();
PyObject *obj;
SWIG_PyDict_GetItemStringRef(cache, type, &obj);
if (obj) {
descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
} else {
swig_module_info *swig_module = SWIG_GetModule(0);
descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
if (descriptor) {
obj = PyCapsule_New((void*) descriptor, NULL, NULL);
if (obj) PyDict_SetItemString(cache, type, obj);
}
}
SWIG_Py_XDECREF(obj);
return descriptor;
}
/*
For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION 0
#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{
if (PyErr_Occurred()) {
PyObject *type = 0;
PyObject *value = 0;
PyObject *traceback = 0;
PyErr_Fetch(&type, &value, &traceback);
if (value) {
PyObject *old_str = PyObject_Str(value);
PyObject *bytes = NULL;
const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
const char *errmesg = tmp ? tmp : "Invalid error message";
SWIG_Py_XINCREF(type);
PyErr_Clear();
if (infront) {
PyErr_Format(type, "%s %s", mesg, errmesg);
} else {
PyErr_Format(type, "%s %s", errmesg, mesg);
}
SWIG_Py_XDECREF(bytes);
SWIG_Py_DECREF(old_str);
}
return 1;
} else {
return 0;
}
}
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
if (PyErr_Occurred()) {
/* add information about failing argument */
char mesg[256];
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
} else {
return 0;
}
}
SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
SwigPyObject *v = (SwigPyObject *)self;
swig_type_info *ty = v ? v->ty : 0;
return ty ? ty->str : "";
}
/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
void *result;
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
PyErr_Clear();
}
return result;
}
#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
PyTypeObject *tp = Py_TYPE(obj);
PyObject *descr;
PyObject *encoded_name;
descrsetfunc f;
int res = -1;
# ifdef Py_USING_UNICODE
if (PyBytes_Check(name)) {
name = PyUnicode_Decode(PyBytes_AsString(name), PyBytes_Size(name), NULL, NULL);
if (!name)
return -1;
} else if (!PyUnicode_Check(name))
# else
if (!PyBytes_Check(name))
# endif
{
PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(Py_TYPE(name));
PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%S'", tpname);
SWIG_Py_DECREF(tpname);
return -1;
} else {
SWIG_Py_INCREF(name);
}
if (!tp->tp_dict) {
if (PyType_Ready(tp) != 0)
goto done;
}
descr = _PyType_Lookup(tp, name);
f = NULL;
if (descr != NULL)
f = Py_TYPE(descr)->tp_descr_set;
if (!f) {
if (PyBytes_Check(name)) {
encoded_name = name;
SWIG_Py_INCREF(name);
} else {
encoded_name = PyUnicode_AsUTF8String(name);
if (!encoded_name)
goto done;
}
PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '%s'", tp->tp_name, PyBytes_AsString(encoded_name));
SWIG_Py_DECREF(encoded_name);
} else {
res = f(descr, obj, value);
}
done:
SWIG_Py_DECREF(name);
return res;
}
#endif
#ifdef __cplusplus
}
#endif