/***********************************************************************
* This file contains the runtime support for Python modules
* and includes code for managing global variables and pointer
* Author : David Beazley (beazley@cs.uchicago.edu)
************************************************************************/
#define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
#define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
/* Python-specific SWIG API */
#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
/* -----------------------------------------------------------------------------
* ----------------------------------------------------------------------------- */
Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
C/C++ pointers in the python side. Very useful for debugging, but
#if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
# define SWIG_COBJECT_TYPES
/* Flags for pointer conversion */
#define SWIG_POINTER_EXCEPTION 0x1
#define SWIG_POINTER_DISOWN 0x2
/* Add PyOS_snprintf for old Pythons */
#if PY_VERSION_HEX < 0x02020000
#define PyOS_snprintf snprintf
/* -----------------------------------------------------------------------------
* Create a new pointer string
* ----------------------------------------------------------------------------- */
#define SWIG_BUFFER_SIZE 1024
/* A crude PyString_FromFormat implementation for old Pythons */
#if PY_VERSION_HEX < 0x02020000
PyString_FromFormat(const char *fmt, ...) {
char buf[SWIG_BUFFER_SIZE * 2];
res = vsnprintf(buf, sizeof(buf), fmt, ap);
return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
#if PY_VERSION_HEX < 0x01060000
#define PyObject_Del(op) PyMem_DEL((op))
#if defined(SWIG_COBJECT_TYPES)
#if !defined(SWIG_COBJECT_PYTHON)
/* -----------------------------------------------------------------------------
* Implements a simple Swig Object type, and use it instead of PyCObject
* ----------------------------------------------------------------------------- */
/* Declarations for objects of type PySwigObject */
PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
PySwigObject_repr(PySwigObject *v)
char result[SWIG_BUFFER_SIZE];
return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
PyString_FromFormat("<Swig Object at %s>", result) : 0;
PySwigObject_str(PySwigObject *v)
char result[SWIG_BUFFER_SIZE];
return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
PyString_FromString(result) : 0;
PySwigObject_long(PySwigObject *v)
return PyLong_FromVoidPtr(v->ptr);
PySwigObject_format(const char* fmt, PySwigObject *v)
PyObject *args = PyTuple_New(1);
if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
PyObject *ofmt = PyString_FromString(fmt);
res = PyString_Format(ofmt,args);
PySwigObject_oct(PySwigObject *v)
return PySwigObject_format("%o",v);
PySwigObject_hex(PySwigObject *v)
return PySwigObject_format("%x",v);
PySwigObject_compare(PySwigObject *v, PySwigObject *w)
int c = strcmp(v->desc, w->desc);
return (i < j) ? -1 : ((i > j) ? 1 : 0);
PySwigObject_dealloc(PySwigObject *self)
SWIGRUNTIME PyTypeObject*
PySwigObject_type(void) {
static char pyswigobject_type__doc__[] =
"Swig object carries a C/C++ instance pointer";
static PyNumberMethods PySwigObject_as_number = {
(binaryfunc)0, /*nb_add*/
(binaryfunc)0, /*nb_subtract*/
(binaryfunc)0, /*nb_multiply*/
(binaryfunc)0, /*nb_divide*/
(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_nonzero*/
(coercion)0, /*nb_coerce*/
(unaryfunc)PySwigObject_long, /*nb_int*/
(unaryfunc)PySwigObject_long, /*nb_long*/
(unaryfunc)0, /*nb_float*/
(unaryfunc)PySwigObject_oct, /*nb_oct*/
(unaryfunc)PySwigObject_hex, /*nb_hex*/
#if PY_VERSION_HEX >= 0x02020000
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
#elif PY_VERSION_HEX >= 0x02000000
0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
static PyTypeObject pyswigobject_type
#if !defined(__cplusplus)
static int type_init = 0;
PyObject_HEAD_INIT(&PyType_Type)
(char *)"PySwigObject", /*tp_name*/
sizeof(PySwigObject), /*tp_basicsize*/
(destructor)PySwigObject_dealloc, /*tp_dealloc*/
(printfunc)PySwigObject_print, /*tp_print*/
(getattrfunc)0, /*tp_getattr*/
(setattrfunc)0, /*tp_setattr*/
(cmpfunc)PySwigObject_compare, /*tp_compare*/
(reprfunc)PySwigObject_repr, /*tp_repr*/
&PySwigObject_as_number, /*tp_as_number*/
(ternaryfunc)0, /*tp_call*/
(reprfunc)PySwigObject_str, /*tp_str*/
/* Space for future expansion */
pyswigobject_type__doc__, /* Documentation string */
#if PY_VERSION_HEX >= 0x02000000
#if PY_VERSION_HEX >= 0x02010000
0, /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#if PY_VERSION_HEX >= 0x02030000
0,0,0,0 /* tp_alloc -> tp_next */
#if !defined(__cplusplus)
return &pyswigobject_type;
PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
PySwigObject_AsVoidPtr(PyObject *self)
return ((PySwigObject *)self)->ptr;
SWIGRUNTIMEINLINE const char *
PySwigObject_GetDesc(PyObject *self)
return ((PySwigObject *)self)->desc;
PySwigObject_Check(PyObject *op) {
return ((op)->ob_type == PySwigObject_type())
|| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
/* -----------------------------------------------------------------------------
* Implements a simple Swig Packed type, and use it instead of string
* ----------------------------------------------------------------------------- */
PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
char result[SWIG_BUFFER_SIZE];
fputs("<Swig Packed ", fp);
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
PySwigPacked_repr(PySwigPacked *v)
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
return PyString_FromFormat("<Swig Packed %s>", v->desc);
PySwigPacked_str(PySwigPacked *v)
char result[SWIG_BUFFER_SIZE];
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
return PyString_FromFormat("%s%s", result, v->desc);
return PyString_FromString(v->desc);
PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
int c = strcmp(v->desc, w->desc);
int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
PySwigPacked_dealloc(PySwigPacked *self)
SWIGRUNTIME PyTypeObject*
PySwigPacked_type(void) {
static char pyswigpacked_type__doc__[] =
"Swig object carries a C/C++ instance pointer";
static PyTypeObject pyswigpacked_type
#if !defined(__cplusplus)
static int type_init = 0;
PyObject_HEAD_INIT(&PyType_Type)
(char *)"PySwigPacked", /*tp_name*/
sizeof(PySwigPacked), /*tp_basicsize*/
(destructor)PySwigPacked_dealloc, /*tp_dealloc*/
(printfunc)PySwigPacked_print, /*tp_print*/
(getattrfunc)0, /*tp_getattr*/
(setattrfunc)0, /*tp_setattr*/
(cmpfunc)PySwigPacked_compare, /*tp_compare*/
(reprfunc)PySwigPacked_repr, /*tp_repr*/
(ternaryfunc)0, /*tp_call*/
(reprfunc)PySwigPacked_str, /*tp_str*/
/* Space for future expansion */
pyswigpacked_type__doc__, /* Documentation string */
#if PY_VERSION_HEX >= 0x02000000
#if PY_VERSION_HEX >= 0x02010000
0, /* tp_weaklistoffset */
#if PY_VERSION_HEX >= 0x02020000
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
#if PY_VERSION_HEX >= 0x02030000
0,0,0,0 /* tp_alloc -> tp_next */
#if !defined(__cplusplus)
return &pyswigpacked_type;
PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
void *pack = malloc(size);
return (PyObject *) self;
SWIGRUNTIMEINLINE const char *
PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
PySwigPacked *self = (PySwigPacked *)obj;
if (self->size != size) return 0;
memcpy(ptr, self->pack, size);
SWIGRUNTIMEINLINE const char *
PySwigPacked_GetDesc(PyObject *self)
return ((PySwigPacked *)self)->desc;
PySwigPacked_Check(PyObject *op) {
return ((op)->ob_type == PySwigPacked_type())
|| (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
/* -----------------------------------------------------------------------------
* Use the old Python PyCObject instead of PySwigObject
* ----------------------------------------------------------------------------- */
#define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
#define PySwigObject_Check(obj) PyCObject_Check(obj)
#define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
#define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
/* -----------------------------------------------------------------------------
* ----------------------------------------------------------------------------- */
SWIG_Python_TypeError(const char *type, PyObject *obj)
#if defined(SWIG_COBJECT_TYPES)
if (obj && PySwigObject_Check(obj)) {
const char *otype = (const char *) PySwigObject_GetDesc(obj);
PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
const char *otype = (obj ? obj->ob_type->tp_name : 0);
PyObject *str = PyObject_Str(obj);
const char *cstr = str ? PyString_AsString(str) : 0;
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
PyErr_Format(PyExc_TypeError, "unexpected type is received");
SWIG_Python_NullRef(const char *type)
PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
PyErr_Format(PyExc_TypeError, "null reference was received");
SWIG_Python_AddErrMesg(const char* mesg, int infront)
PyErr_Fetch(&type, &value, &traceback);
PyObject *old_str = PyObject_Str(value);
PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
SWIG_Python_ArgFail(int argnum)
/* add information about failing argument */
PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
return SWIG_Python_AddErrMesg(mesg, 1);
/* -----------------------------------------------------------------------------
* pointers/data manipulation
* ----------------------------------------------------------------------------- */
/* Convert a pointer value */
SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
static PyObject *SWIG_this = 0;
#ifdef SWIG_COBJECT_TYPES
if (!(PySwigObject_Check(obj))) {
SWIG_this = PyString_FromString("this");
obj = PyObject_GetAttr(obj,SWIG_this);
if (!obj) goto type_error;
if (!PySwigObject_Check(obj)) {
vptr = PySwigObject_AsVoidPtr(obj);
c = (const char *) PySwigObject_GetDesc(obj);
if (newref) { Py_DECREF(obj); }
if (!(PyString_Check(obj))) {
SWIG_this = PyString_FromString("this");
obj = PyObject_GetAttr(obj,SWIG_this);
if (!obj) goto type_error;
if (!PyString_Check(obj)) {
c = PyString_AsString(obj);
/* Pointer values must start with leading underscore */
c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
if (newref) { Py_DECREF(obj); }
tc = SWIG_TypeCheck(c,ty);
if (!tc) goto type_error;
*ptr = SWIG_TypeCast(tc,vptr);
if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
if (PyCFunction_Check(obj)) {
/* here we get the method pointer for callbacks */
char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
c = doc ? strstr(doc, "swig_ptr: ") : 0;
c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
if (flags & SWIG_POINTER_EXCEPTION) {
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
SWIG_Python_TypeError("C/C++ pointer", obj);
/* Convert a pointer value, signal an exception on a type mismatch */
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
if (flags & SWIG_POINTER_EXCEPTION) {
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
SWIG_Python_ArgFail(argnum);
/* Convert a packed value value */
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
c = PySwigPacked_UnpackData(obj, ptr, sz);
if ((!obj) || (!PyString_Check(obj))) goto type_error;
c = PyString_AsString(obj);
/* Pointer values must start with leading underscore */
c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
tc = SWIG_TypeCheck(c,ty);
if (!tc) goto type_error;
if (flags & SWIG_POINTER_EXCEPTION) {
SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
SWIG_Python_TypeError("C/C++ packed data", obj);
/* Create a new array object */
SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
#ifdef SWIG_COBJECT_TYPES
robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
char result[SWIG_BUFFER_SIZE];
robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
PyString_FromString(result) : 0;
if (!robj || (robj == Py_None)) return robj;
PyObject *args = Py_BuildValue((char*)"(O)", robj);
inst = PyObject_CallObject((PyObject *) type->clientdata, args);
PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
#if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
char result[SWIG_BUFFER_SIZE];
robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
PyString_FromString(result) : 0;
/* -----------------------------------------------------------------------------*
* -----------------------------------------------------------------------------*/
void *SWIG_ReturnGlobalTypeList(void *);
SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void) {
static void *type_pointer = (void *)0;
/* first check if module already created */
type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
type_pointer = (void *)0;
return (swig_module_info *) type_pointer;
/* PyModule_AddObject function was introduced in Python 2.0. The following function
is copied out of Python/modsupport.c in python version 2.3.4 */
PyModule_AddObject(PyObject *m, char *name, PyObject *o)
if (!PyModule_Check(m)) {
PyErr_SetString(PyExc_TypeError,
"PyModule_AddObject() needs module as first arg");
PyErr_SetString(PyExc_TypeError,
"PyModule_AddObject() needs non-NULL value");
dict = PyModule_GetDict(m);
/* Internal error -- modules must have a dict! */
PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
if (PyDict_SetItemString(dict, name, o))
SWIG_Python_SetModule(swig_module_info *swig_module) {
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
swig_empty_runtime_method_table);
PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);