| 1 | /*********************************************************************** |
| 2 | * pyrun.swg |
| 3 | * |
| 4 | * This file contains the runtime support for Python modules |
| 5 | * and includes code for managing global variables and pointer |
| 6 | * type checking. |
| 7 | * |
| 8 | * Author : David Beazley (beazley@cs.uchicago.edu) |
| 9 | ************************************************************************/ |
| 10 | |
| 11 | /* Common SWIG API */ |
| 12 | #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags) |
| 13 | #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags) |
| 14 | #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) |
| 15 | |
| 16 | |
| 17 | /* Python-specific SWIG API */ |
| 18 | #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags) |
| 19 | #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) |
| 20 | |
| 21 | /* Runtime API */ |
| 22 | #define SWIG_GetModule(clientdata) SWIG_Python_GetModule() |
| 23 | #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) |
| 24 | |
| 25 | /* ----------------------------------------------------------------------------- |
| 26 | * Pointer declarations |
| 27 | * ----------------------------------------------------------------------------- */ |
| 28 | /* |
| 29 | Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent |
| 30 | C/C++ pointers in the python side. Very useful for debugging, but |
| 31 | not always safe. |
| 32 | */ |
| 33 | #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES) |
| 34 | # define SWIG_COBJECT_TYPES |
| 35 | #endif |
| 36 | |
| 37 | /* Flags for pointer conversion */ |
| 38 | #define SWIG_POINTER_EXCEPTION 0x1 |
| 39 | #define SWIG_POINTER_DISOWN 0x2 |
| 40 | |
| 41 | |
| 42 | /* Add PyOS_snprintf for old Pythons */ |
| 43 | #if PY_VERSION_HEX < 0x02020000 |
| 44 | #define PyOS_snprintf snprintf |
| 45 | #endif |
| 46 | |
| 47 | #ifdef __cplusplus |
| 48 | extern "C" { |
| 49 | #endif |
| 50 | |
| 51 | /* ----------------------------------------------------------------------------- |
| 52 | * Create a new pointer string |
| 53 | * ----------------------------------------------------------------------------- */ |
| 54 | #ifndef SWIG_BUFFER_SIZE |
| 55 | #define SWIG_BUFFER_SIZE 1024 |
| 56 | #endif |
| 57 | |
| 58 | /* A crude PyString_FromFormat implementation for old Pythons */ |
| 59 | #if PY_VERSION_HEX < 0x02020000 |
| 60 | static PyObject * |
| 61 | PyString_FromFormat(const char *fmt, ...) { |
| 62 | va_list ap; |
| 63 | char buf[SWIG_BUFFER_SIZE * 2]; |
| 64 | int res; |
| 65 | va_start(ap, fmt); |
| 66 | res = vsnprintf(buf, sizeof(buf), fmt, ap); |
| 67 | va_end(ap); |
| 68 | return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf); |
| 69 | } |
| 70 | #endif |
| 71 | |
| 72 | #if PY_VERSION_HEX < 0x01060000 |
| 73 | #define PyObject_Del(op) PyMem_DEL((op)) |
| 74 | #endif |
| 75 | |
| 76 | #if defined(SWIG_COBJECT_TYPES) |
| 77 | #if !defined(SWIG_COBJECT_PYTHON) |
| 78 | /* ----------------------------------------------------------------------------- |
| 79 | * Implements a simple Swig Object type, and use it instead of PyCObject |
| 80 | * ----------------------------------------------------------------------------- */ |
| 81 | |
| 82 | typedef struct { |
| 83 | PyObject_HEAD |
| 84 | void *ptr; |
| 85 | const char *desc; |
| 86 | } PySwigObject; |
| 87 | |
| 88 | /* Declarations for objects of type PySwigObject */ |
| 89 | |
| 90 | SWIGRUNTIME int |
| 91 | PySwigObject_print(PySwigObject *v, FILE *fp, int flags) |
| 92 | { |
| 93 | char result[SWIG_BUFFER_SIZE]; |
| 94 | flags = flags; |
| 95 | if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) { |
| 96 | fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp); |
| 97 | return 0; |
| 98 | } else { |
| 99 | return 1; |
| 100 | } |
| 101 | } |
| 102 | |
| 103 | SWIGRUNTIME PyObject * |
| 104 | PySwigObject_repr(PySwigObject *v) |
| 105 | { |
| 106 | char result[SWIG_BUFFER_SIZE]; |
| 107 | return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ? |
| 108 | PyString_FromFormat("<Swig Object at %s>", result) : 0; |
| 109 | } |
| 110 | |
| 111 | SWIGRUNTIME PyObject * |
| 112 | PySwigObject_str(PySwigObject *v) |
| 113 | { |
| 114 | char result[SWIG_BUFFER_SIZE]; |
| 115 | return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ? |
| 116 | PyString_FromString(result) : 0; |
| 117 | } |
| 118 | |
| 119 | SWIGRUNTIME PyObject * |
| 120 | PySwigObject_long(PySwigObject *v) |
| 121 | { |
| 122 | return PyLong_FromVoidPtr(v->ptr); |
| 123 | } |
| 124 | |
| 125 | SWIGRUNTIME PyObject * |
| 126 | PySwigObject_format(const char* fmt, PySwigObject *v) |
| 127 | { |
| 128 | PyObject *res = NULL; |
| 129 | PyObject *args = PyTuple_New(1); |
| 130 | if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) { |
| 131 | PyObject *ofmt = PyString_FromString(fmt); |
| 132 | if (ofmt) { |
| 133 | res = PyString_Format(ofmt,args); |
| 134 | Py_DECREF(ofmt); |
| 135 | } |
| 136 | Py_DECREF(args); |
| 137 | } |
| 138 | return res; |
| 139 | } |
| 140 | |
| 141 | SWIGRUNTIME PyObject * |
| 142 | PySwigObject_oct(PySwigObject *v) |
| 143 | { |
| 144 | return PySwigObject_format("%o",v); |
| 145 | } |
| 146 | |
| 147 | SWIGRUNTIME PyObject * |
| 148 | PySwigObject_hex(PySwigObject *v) |
| 149 | { |
| 150 | return PySwigObject_format("%x",v); |
| 151 | } |
| 152 | |
| 153 | SWIGRUNTIME int |
| 154 | PySwigObject_compare(PySwigObject *v, PySwigObject *w) |
| 155 | { |
| 156 | int c = strcmp(v->desc, w->desc); |
| 157 | if (c) { |
| 158 | return (c > 0) ? 1 : -1; |
| 159 | } else { |
| 160 | void *i = v->ptr; |
| 161 | void *j = w->ptr; |
| 162 | return (i < j) ? -1 : ((i > j) ? 1 : 0); |
| 163 | } |
| 164 | } |
| 165 | |
| 166 | SWIGRUNTIME void |
| 167 | PySwigObject_dealloc(PySwigObject *self) |
| 168 | { |
| 169 | PyObject_Del(self); |
| 170 | } |
| 171 | |
| 172 | SWIGRUNTIME PyTypeObject* |
| 173 | PySwigObject_type(void) { |
| 174 | static char pyswigobject_type__doc__[] = |
| 175 | "Swig object carries a C/C++ instance pointer"; |
| 176 | |
| 177 | static PyNumberMethods PySwigObject_as_number = { |
| 178 | (binaryfunc)0, /*nb_add*/ |
| 179 | (binaryfunc)0, /*nb_subtract*/ |
| 180 | (binaryfunc)0, /*nb_multiply*/ |
| 181 | (binaryfunc)0, /*nb_divide*/ |
| 182 | (binaryfunc)0, /*nb_remainder*/ |
| 183 | (binaryfunc)0, /*nb_divmod*/ |
| 184 | (ternaryfunc)0,/*nb_power*/ |
| 185 | (unaryfunc)0, /*nb_negative*/ |
| 186 | (unaryfunc)0, /*nb_positive*/ |
| 187 | (unaryfunc)0, /*nb_absolute*/ |
| 188 | (inquiry)0, /*nb_nonzero*/ |
| 189 | 0, /*nb_invert*/ |
| 190 | 0, /*nb_lshift*/ |
| 191 | 0, /*nb_rshift*/ |
| 192 | 0, /*nb_and*/ |
| 193 | 0, /*nb_xor*/ |
| 194 | 0, /*nb_or*/ |
| 195 | (coercion)0, /*nb_coerce*/ |
| 196 | (unaryfunc)PySwigObject_long, /*nb_int*/ |
| 197 | (unaryfunc)PySwigObject_long, /*nb_long*/ |
| 198 | (unaryfunc)0, /*nb_float*/ |
| 199 | (unaryfunc)PySwigObject_oct, /*nb_oct*/ |
| 200 | (unaryfunc)PySwigObject_hex, /*nb_hex*/ |
| 201 | #if PY_VERSION_HEX >= 0x02020000 |
| 202 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */ |
| 203 | #elif PY_VERSION_HEX >= 0x02000000 |
| 204 | 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */ |
| 205 | #endif |
| 206 | }; |
| 207 | |
| 208 | static PyTypeObject pyswigobject_type |
| 209 | #if !defined(__cplusplus) |
| 210 | ; |
| 211 | static int type_init = 0; |
| 212 | if (!type_init) { |
| 213 | PyTypeObject tmp |
| 214 | #endif |
| 215 | = { |
| 216 | PyObject_HEAD_INIT(&PyType_Type) |
| 217 | 0, /*ob_size*/ |
| 218 | (char *)"PySwigObject", /*tp_name*/ |
| 219 | sizeof(PySwigObject), /*tp_basicsize*/ |
| 220 | 0, /*tp_itemsize*/ |
| 221 | /* methods */ |
| 222 | (destructor)PySwigObject_dealloc, /*tp_dealloc*/ |
| 223 | (printfunc)PySwigObject_print, /*tp_print*/ |
| 224 | (getattrfunc)0, /*tp_getattr*/ |
| 225 | (setattrfunc)0, /*tp_setattr*/ |
| 226 | (cmpfunc)PySwigObject_compare, /*tp_compare*/ |
| 227 | (reprfunc)PySwigObject_repr, /*tp_repr*/ |
| 228 | &PySwigObject_as_number, /*tp_as_number*/ |
| 229 | 0, /*tp_as_sequence*/ |
| 230 | 0, /*tp_as_mapping*/ |
| 231 | (hashfunc)0, /*tp_hash*/ |
| 232 | (ternaryfunc)0, /*tp_call*/ |
| 233 | (reprfunc)PySwigObject_str, /*tp_str*/ |
| 234 | /* Space for future expansion */ |
| 235 | 0,0,0,0, |
| 236 | pyswigobject_type__doc__, /* Documentation string */ |
| 237 | #if PY_VERSION_HEX >= 0x02000000 |
| 238 | 0, /* tp_traverse */ |
| 239 | 0, /* tp_clear */ |
| 240 | #endif |
| 241 | #if PY_VERSION_HEX >= 0x02010000 |
| 242 | 0, /* tp_richcompare */ |
| 243 | 0, /* tp_weaklistoffset */ |
| 244 | #endif |
| 245 | #if PY_VERSION_HEX >= 0x02020000 |
| 246 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ |
| 247 | #endif |
| 248 | #if PY_VERSION_HEX >= 0x02030000 |
| 249 | 0, /* tp_del */ |
| 250 | #endif |
| 251 | #ifdef COUNT_ALLOCS |
| 252 | 0,0,0,0 /* tp_alloc -> tp_next */ |
| 253 | #endif |
| 254 | }; |
| 255 | #if !defined(__cplusplus) |
| 256 | pyswigobject_type = tmp; |
| 257 | type_init = 1; |
| 258 | } |
| 259 | #endif |
| 260 | return &pyswigobject_type; |
| 261 | } |
| 262 | |
| 263 | SWIGRUNTIME PyObject * |
| 264 | PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc) |
| 265 | { |
| 266 | PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type()); |
| 267 | if (self) { |
| 268 | self->ptr = ptr; |
| 269 | self->desc = desc; |
| 270 | } |
| 271 | return (PyObject *)self; |
| 272 | } |
| 273 | |
| 274 | SWIGRUNTIMEINLINE void * |
| 275 | PySwigObject_AsVoidPtr(PyObject *self) |
| 276 | { |
| 277 | return ((PySwigObject *)self)->ptr; |
| 278 | } |
| 279 | |
| 280 | SWIGRUNTIMEINLINE const char * |
| 281 | PySwigObject_GetDesc(PyObject *self) |
| 282 | { |
| 283 | return ((PySwigObject *)self)->desc; |
| 284 | } |
| 285 | |
| 286 | SWIGRUNTIMEINLINE int |
| 287 | PySwigObject_Check(PyObject *op) { |
| 288 | return ((op)->ob_type == PySwigObject_type()) |
| 289 | || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0); |
| 290 | } |
| 291 | |
| 292 | /* ----------------------------------------------------------------------------- |
| 293 | * Implements a simple Swig Packed type, and use it instead of string |
| 294 | * ----------------------------------------------------------------------------- */ |
| 295 | |
| 296 | typedef struct { |
| 297 | PyObject_HEAD |
| 298 | void *pack; |
| 299 | const char *desc; |
| 300 | size_t size; |
| 301 | } PySwigPacked; |
| 302 | |
| 303 | SWIGRUNTIME int |
| 304 | PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags) |
| 305 | { |
| 306 | char result[SWIG_BUFFER_SIZE]; |
| 307 | flags = flags; |
| 308 | fputs("<Swig Packed ", fp); |
| 309 | if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { |
| 310 | fputs("at ", fp); |
| 311 | fputs(result, fp); |
| 312 | } |
| 313 | fputs(v->desc,fp); |
| 314 | fputs(">", fp); |
| 315 | return 0; |
| 316 | } |
| 317 | |
| 318 | SWIGRUNTIME PyObject * |
| 319 | PySwigPacked_repr(PySwigPacked *v) |
| 320 | { |
| 321 | char result[SWIG_BUFFER_SIZE]; |
| 322 | if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { |
| 323 | return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc); |
| 324 | } else { |
| 325 | return PyString_FromFormat("<Swig Packed %s>", v->desc); |
| 326 | } |
| 327 | } |
| 328 | |
| 329 | SWIGRUNTIME PyObject * |
| 330 | PySwigPacked_str(PySwigPacked *v) |
| 331 | { |
| 332 | char result[SWIG_BUFFER_SIZE]; |
| 333 | if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ |
| 334 | return PyString_FromFormat("%s%s", result, v->desc); |
| 335 | } else { |
| 336 | return PyString_FromString(v->desc); |
| 337 | } |
| 338 | } |
| 339 | |
| 340 | SWIGRUNTIME int |
| 341 | PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w) |
| 342 | { |
| 343 | int c = strcmp(v->desc, w->desc); |
| 344 | if (c) { |
| 345 | return (c > 0) ? 1 : -1; |
| 346 | } else { |
| 347 | size_t i = v->size; |
| 348 | size_t j = w->size; |
| 349 | int s = (i < j) ? -1 : ((i > j) ? 1 : 0); |
| 350 | return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size); |
| 351 | } |
| 352 | } |
| 353 | |
| 354 | SWIGRUNTIME void |
| 355 | PySwigPacked_dealloc(PySwigPacked *self) |
| 356 | { |
| 357 | free(self->pack); |
| 358 | PyObject_Del(self); |
| 359 | } |
| 360 | |
| 361 | SWIGRUNTIME PyTypeObject* |
| 362 | PySwigPacked_type(void) { |
| 363 | static char pyswigpacked_type__doc__[] = |
| 364 | "Swig object carries a C/C++ instance pointer"; |
| 365 | static PyTypeObject pyswigpacked_type |
| 366 | #if !defined(__cplusplus) |
| 367 | ; |
| 368 | static int type_init = 0; |
| 369 | if (!type_init) { |
| 370 | PyTypeObject tmp |
| 371 | #endif |
| 372 | = { |
| 373 | PyObject_HEAD_INIT(&PyType_Type) |
| 374 | 0, /*ob_size*/ |
| 375 | (char *)"PySwigPacked", /*tp_name*/ |
| 376 | sizeof(PySwigPacked), /*tp_basicsize*/ |
| 377 | 0, /*tp_itemsize*/ |
| 378 | /* methods */ |
| 379 | (destructor)PySwigPacked_dealloc, /*tp_dealloc*/ |
| 380 | (printfunc)PySwigPacked_print, /*tp_print*/ |
| 381 | (getattrfunc)0, /*tp_getattr*/ |
| 382 | (setattrfunc)0, /*tp_setattr*/ |
| 383 | (cmpfunc)PySwigPacked_compare, /*tp_compare*/ |
| 384 | (reprfunc)PySwigPacked_repr, /*tp_repr*/ |
| 385 | 0, /*tp_as_number*/ |
| 386 | 0, /*tp_as_sequence*/ |
| 387 | 0, /*tp_as_mapping*/ |
| 388 | (hashfunc)0, /*tp_hash*/ |
| 389 | (ternaryfunc)0, /*tp_call*/ |
| 390 | (reprfunc)PySwigPacked_str, /*tp_str*/ |
| 391 | /* Space for future expansion */ |
| 392 | 0,0,0,0, |
| 393 | pyswigpacked_type__doc__, /* Documentation string */ |
| 394 | #if PY_VERSION_HEX >= 0x02000000 |
| 395 | 0, /* tp_traverse */ |
| 396 | 0, /* tp_clear */ |
| 397 | #endif |
| 398 | #if PY_VERSION_HEX >= 0x02010000 |
| 399 | 0, /* tp_richcompare */ |
| 400 | 0, /* tp_weaklistoffset */ |
| 401 | #endif |
| 402 | #if PY_VERSION_HEX >= 0x02020000 |
| 403 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ |
| 404 | #endif |
| 405 | #if PY_VERSION_HEX >= 0x02030000 |
| 406 | 0, /* tp_del */ |
| 407 | #endif |
| 408 | #ifdef COUNT_ALLOCS |
| 409 | 0,0,0,0 /* tp_alloc -> tp_next */ |
| 410 | #endif |
| 411 | }; |
| 412 | #if !defined(__cplusplus) |
| 413 | pyswigpacked_type = tmp; |
| 414 | type_init = 1; |
| 415 | } |
| 416 | #endif |
| 417 | return &pyswigpacked_type; |
| 418 | } |
| 419 | |
| 420 | SWIGRUNTIME PyObject * |
| 421 | PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc) |
| 422 | { |
| 423 | PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type()); |
| 424 | if (self == NULL) { |
| 425 | return NULL; |
| 426 | } else { |
| 427 | void *pack = malloc(size); |
| 428 | if (pack) { |
| 429 | memcpy(pack, ptr, size); |
| 430 | self->pack = pack; |
| 431 | self->desc = desc; |
| 432 | self->size = size; |
| 433 | return (PyObject *) self; |
| 434 | } |
| 435 | return NULL; |
| 436 | } |
| 437 | } |
| 438 | |
| 439 | SWIGRUNTIMEINLINE const char * |
| 440 | PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size) |
| 441 | { |
| 442 | PySwigPacked *self = (PySwigPacked *)obj; |
| 443 | if (self->size != size) return 0; |
| 444 | memcpy(ptr, self->pack, size); |
| 445 | return self->desc; |
| 446 | } |
| 447 | |
| 448 | SWIGRUNTIMEINLINE const char * |
| 449 | PySwigPacked_GetDesc(PyObject *self) |
| 450 | { |
| 451 | return ((PySwigPacked *)self)->desc; |
| 452 | } |
| 453 | |
| 454 | SWIGRUNTIMEINLINE int |
| 455 | PySwigPacked_Check(PyObject *op) { |
| 456 | return ((op)->ob_type == PySwigPacked_type()) |
| 457 | || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0); |
| 458 | } |
| 459 | |
| 460 | #else |
| 461 | /* ----------------------------------------------------------------------------- |
| 462 | * Use the old Python PyCObject instead of PySwigObject |
| 463 | * ----------------------------------------------------------------------------- */ |
| 464 | |
| 465 | #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj) |
| 466 | #define PySwigObject_Check(obj) PyCObject_Check(obj) |
| 467 | #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj) |
| 468 | #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL) |
| 469 | |
| 470 | #endif |
| 471 | |
| 472 | #endif |
| 473 | |
| 474 | /* ----------------------------------------------------------------------------- |
| 475 | * errors manipulation |
| 476 | * ----------------------------------------------------------------------------- */ |
| 477 | |
| 478 | SWIGRUNTIME void |
| 479 | SWIG_Python_TypeError(const char *type, PyObject *obj) |
| 480 | { |
| 481 | if (type) { |
| 482 | #if defined(SWIG_COBJECT_TYPES) |
| 483 | if (obj && PySwigObject_Check(obj)) { |
| 484 | const char *otype = (const char *) PySwigObject_GetDesc(obj); |
| 485 | if (otype) { |
| 486 | PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received", |
| 487 | type, otype); |
| 488 | return; |
| 489 | } |
| 490 | } else |
| 491 | #endif |
| 492 | { |
| 493 | const char *otype = (obj ? obj->ob_type->tp_name : 0); |
| 494 | if (otype) { |
| 495 | PyObject *str = PyObject_Str(obj); |
| 496 | const char *cstr = str ? PyString_AsString(str) : 0; |
| 497 | if (cstr) { |
| 498 | PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", |
| 499 | type, otype, cstr); |
| 500 | } else { |
| 501 | PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", |
| 502 | type, otype); |
| 503 | } |
| 504 | Py_XDECREF(str); |
| 505 | return; |
| 506 | } |
| 507 | } |
| 508 | PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); |
| 509 | } else { |
| 510 | PyErr_Format(PyExc_TypeError, "unexpected type is received"); |
| 511 | } |
| 512 | } |
| 513 | |
| 514 | SWIGRUNTIMEINLINE void |
| 515 | SWIG_Python_NullRef(const char *type) |
| 516 | { |
| 517 | if (type) { |
| 518 | PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type); |
| 519 | } else { |
| 520 | PyErr_Format(PyExc_TypeError, "null reference was received"); |
| 521 | } |
| 522 | } |
| 523 | |
| 524 | SWIGRUNTIME int |
| 525 | SWIG_Python_AddErrMesg(const char* mesg, int infront) |
| 526 | { |
| 527 | if (PyErr_Occurred()) { |
| 528 | PyObject *type = 0; |
| 529 | PyObject *value = 0; |
| 530 | PyObject *traceback = 0; |
| 531 | PyErr_Fetch(&type, &value, &traceback); |
| 532 | if (value) { |
| 533 | PyObject *old_str = PyObject_Str(value); |
| 534 | Py_XINCREF(type); |
| 535 | PyErr_Clear(); |
| 536 | if (infront) { |
| 537 | PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str)); |
| 538 | } else { |
| 539 | PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg); |
| 540 | } |
| 541 | Py_DECREF(old_str); |
| 542 | } |
| 543 | return 1; |
| 544 | } else { |
| 545 | return 0; |
| 546 | } |
| 547 | } |
| 548 | |
| 549 | SWIGRUNTIME int |
| 550 | SWIG_Python_ArgFail(int argnum) |
| 551 | { |
| 552 | if (PyErr_Occurred()) { |
| 553 | /* add information about failing argument */ |
| 554 | char mesg[256]; |
| 555 | PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); |
| 556 | return SWIG_Python_AddErrMesg(mesg, 1); |
| 557 | } else { |
| 558 | return 0; |
| 559 | } |
| 560 | } |
| 561 | |
| 562 | |
| 563 | /* ----------------------------------------------------------------------------- |
| 564 | * pointers/data manipulation |
| 565 | * ----------------------------------------------------------------------------- */ |
| 566 | |
| 567 | /* Convert a pointer value */ |
| 568 | SWIGRUNTIME int |
| 569 | SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) { |
| 570 | swig_cast_info *tc; |
| 571 | const char *c = 0; |
| 572 | static PyObject *SWIG_this = 0; |
| 573 | int newref = 0; |
| 574 | PyObject *pyobj = 0; |
| 575 | void *vptr; |
| 576 | |
| 577 | if (!obj) return 0; |
| 578 | if (obj == Py_None) { |
| 579 | *ptr = 0; |
| 580 | return 0; |
| 581 | } |
| 582 | |
| 583 | #ifdef SWIG_COBJECT_TYPES |
| 584 | if (!(PySwigObject_Check(obj))) { |
| 585 | if (!SWIG_this) |
| 586 | SWIG_this = PyString_FromString("this"); |
| 587 | pyobj = obj; |
| 588 | obj = PyObject_GetAttr(obj,SWIG_this); |
| 589 | newref = 1; |
| 590 | if (!obj) goto type_error; |
| 591 | if (!PySwigObject_Check(obj)) { |
| 592 | Py_DECREF(obj); |
| 593 | goto type_error; |
| 594 | } |
| 595 | } |
| 596 | vptr = PySwigObject_AsVoidPtr(obj); |
| 597 | c = (const char *) PySwigObject_GetDesc(obj); |
| 598 | if (newref) { Py_DECREF(obj); } |
| 599 | goto type_check; |
| 600 | #else |
| 601 | if (!(PyString_Check(obj))) { |
| 602 | if (!SWIG_this) |
| 603 | SWIG_this = PyString_FromString("this"); |
| 604 | pyobj = obj; |
| 605 | obj = PyObject_GetAttr(obj,SWIG_this); |
| 606 | newref = 1; |
| 607 | if (!obj) goto type_error; |
| 608 | if (!PyString_Check(obj)) { |
| 609 | Py_DECREF(obj); |
| 610 | goto type_error; |
| 611 | } |
| 612 | } |
| 613 | c = PyString_AsString(obj); |
| 614 | /* Pointer values must start with leading underscore */ |
| 615 | c = SWIG_UnpackVoidPtr(c, &vptr, ty->name); |
| 616 | if (newref) { Py_DECREF(obj); } |
| 617 | if (!c) goto type_error; |
| 618 | #endif |
| 619 | |
| 620 | type_check: |
| 621 | if (ty) { |
| 622 | tc = SWIG_TypeCheck(c,ty); |
| 623 | if (!tc) goto type_error; |
| 624 | *ptr = SWIG_TypeCast(tc,vptr); |
| 625 | } else { |
| 626 | *ptr = vptr; |
| 627 | } |
| 628 | if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) { |
| 629 | PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False); |
| 630 | } |
| 631 | return 0; |
| 632 | |
| 633 | type_error: |
| 634 | PyErr_Clear(); |
| 635 | if (pyobj && !obj) { |
| 636 | obj = pyobj; |
| 637 | if (PyCFunction_Check(obj)) { |
| 638 | /* here we get the method pointer for callbacks */ |
| 639 | char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); |
| 640 | c = doc ? strstr(doc, "swig_ptr: ") : 0; |
| 641 | if (c) { |
| 642 | c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0; |
| 643 | if (!c) goto type_error; |
| 644 | goto type_check; |
| 645 | } |
| 646 | } |
| 647 | } |
| 648 | if (flags & SWIG_POINTER_EXCEPTION) { |
| 649 | if (ty) { |
| 650 | SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); |
| 651 | } else { |
| 652 | SWIG_Python_TypeError("C/C++ pointer", obj); |
| 653 | } |
| 654 | } |
| 655 | return -1; |
| 656 | } |
| 657 | |
| 658 | /* Convert a pointer value, signal an exception on a type mismatch */ |
| 659 | SWIGRUNTIME void * |
| 660 | SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) { |
| 661 | void *result; |
| 662 | if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { |
| 663 | PyErr_Clear(); |
| 664 | if (flags & SWIG_POINTER_EXCEPTION) { |
| 665 | SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); |
| 666 | SWIG_Python_ArgFail(argnum); |
| 667 | } |
| 668 | } |
| 669 | return result; |
| 670 | } |
| 671 | |
| 672 | /* Convert a packed value value */ |
| 673 | SWIGRUNTIME int |
| 674 | SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) { |
| 675 | swig_cast_info *tc; |
| 676 | const char *c = 0; |
| 677 | |
| 678 | #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON) |
| 679 | c = PySwigPacked_UnpackData(obj, ptr, sz); |
| 680 | #else |
| 681 | if ((!obj) || (!PyString_Check(obj))) goto type_error; |
| 682 | c = PyString_AsString(obj); |
| 683 | /* Pointer values must start with leading underscore */ |
| 684 | c = SWIG_UnpackDataName(c, ptr, sz, ty->name); |
| 685 | #endif |
| 686 | if (!c) goto type_error; |
| 687 | if (ty) { |
| 688 | tc = SWIG_TypeCheck(c,ty); |
| 689 | if (!tc) goto type_error; |
| 690 | } |
| 691 | return 0; |
| 692 | |
| 693 | type_error: |
| 694 | PyErr_Clear(); |
| 695 | if (flags & SWIG_POINTER_EXCEPTION) { |
| 696 | if (ty) { |
| 697 | SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); |
| 698 | } else { |
| 699 | SWIG_Python_TypeError("C/C++ packed data", obj); |
| 700 | } |
| 701 | } |
| 702 | return -1; |
| 703 | } |
| 704 | |
| 705 | /* Create a new array object */ |
| 706 | SWIGRUNTIME PyObject * |
| 707 | SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) { |
| 708 | PyObject *robj = 0; |
| 709 | if (!type) { |
| 710 | if (!PyErr_Occurred()) { |
| 711 | PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj"); |
| 712 | } |
| 713 | return robj; |
| 714 | } |
| 715 | if (!ptr) { |
| 716 | Py_INCREF(Py_None); |
| 717 | return Py_None; |
| 718 | } |
| 719 | #ifdef SWIG_COBJECT_TYPES |
| 720 | robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name); |
| 721 | #else |
| 722 | { |
| 723 | char result[SWIG_BUFFER_SIZE]; |
| 724 | robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ? |
| 725 | PyString_FromString(result) : 0; |
| 726 | } |
| 727 | #endif |
| 728 | if (!robj || (robj == Py_None)) return robj; |
| 729 | if (type->clientdata) { |
| 730 | PyObject *inst; |
| 731 | PyObject *args = Py_BuildValue((char*)"(O)", robj); |
| 732 | Py_DECREF(robj); |
| 733 | inst = PyObject_CallObject((PyObject *) type->clientdata, args); |
| 734 | Py_DECREF(args); |
| 735 | if (inst) { |
| 736 | if (own) { |
| 737 | PyObject_SetAttrString(inst,(char*)"thisown",Py_True); |
| 738 | } |
| 739 | robj = inst; |
| 740 | } |
| 741 | } |
| 742 | return robj; |
| 743 | } |
| 744 | |
| 745 | SWIGRUNTIME PyObject * |
| 746 | SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { |
| 747 | PyObject *robj = 0; |
| 748 | if (!ptr) { |
| 749 | Py_INCREF(Py_None); |
| 750 | return Py_None; |
| 751 | } |
| 752 | #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON) |
| 753 | robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name); |
| 754 | #else |
| 755 | { |
| 756 | char result[SWIG_BUFFER_SIZE]; |
| 757 | robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ? |
| 758 | PyString_FromString(result) : 0; |
| 759 | } |
| 760 | #endif |
| 761 | return robj; |
| 762 | } |
| 763 | |
| 764 | /* -----------------------------------------------------------------------------* |
| 765 | * Get type list |
| 766 | * -----------------------------------------------------------------------------*/ |
| 767 | |
| 768 | #ifdef SWIG_LINK_RUNTIME |
| 769 | void *SWIG_ReturnGlobalTypeList(void *); |
| 770 | #endif |
| 771 | |
| 772 | SWIGRUNTIME swig_module_info * |
| 773 | SWIG_Python_GetModule(void) { |
| 774 | static void *type_pointer = (void *)0; |
| 775 | /* first check if module already created */ |
| 776 | if (!type_pointer) { |
| 777 | #ifdef SWIG_LINK_RUNTIME |
| 778 | type_pointer = SWIG_ReturnGlobalTypeList((void *)0); |
| 779 | #else |
| 780 | type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, |
| 781 | (char*)"type_pointer" SWIG_TYPE_TABLE_NAME); |
| 782 | if (PyErr_Occurred()) { |
| 783 | PyErr_Clear(); |
| 784 | type_pointer = (void *)0; |
| 785 | } |
| 786 | #endif |
| 787 | } |
| 788 | return (swig_module_info *) type_pointer; |
| 789 | } |
| 790 | |
| 791 | #if PY_MAJOR_VERSION < 2 |
| 792 | /* PyModule_AddObject function was introduced in Python 2.0. The following function |
| 793 | is copied out of Python/modsupport.c in python version 2.3.4 */ |
| 794 | SWIGINTERN int |
| 795 | PyModule_AddObject(PyObject *m, char *name, PyObject *o) |
| 796 | { |
| 797 | PyObject *dict; |
| 798 | if (!PyModule_Check(m)) { |
| 799 | PyErr_SetString(PyExc_TypeError, |
| 800 | "PyModule_AddObject() needs module as first arg"); |
| 801 | return -1; |
| 802 | } |
| 803 | if (!o) { |
| 804 | PyErr_SetString(PyExc_TypeError, |
| 805 | "PyModule_AddObject() needs non-NULL value"); |
| 806 | return -1; |
| 807 | } |
| 808 | |
| 809 | dict = PyModule_GetDict(m); |
| 810 | if (dict == NULL) { |
| 811 | /* Internal error -- modules must have a dict! */ |
| 812 | PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__", |
| 813 | PyModule_GetName(m)); |
| 814 | return -1; |
| 815 | } |
| 816 | if (PyDict_SetItemString(dict, name, o)) |
| 817 | return -1; |
| 818 | Py_DECREF(o); |
| 819 | return 0; |
| 820 | } |
| 821 | #endif |
| 822 | |
| 823 | SWIGRUNTIME void |
| 824 | SWIG_Python_SetModule(swig_module_info *swig_module) { |
| 825 | static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */ |
| 826 | |
| 827 | PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, |
| 828 | swig_empty_runtime_method_table); |
| 829 | PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL); |
| 830 | if (pointer && module) { |
| 831 | PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer); |
| 832 | } |
| 833 | } |
| 834 | |
| 835 | #ifdef __cplusplus |
| 836 | } |
| 837 | #endif |