source/param/param_wrap.c

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.35
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #define SWIGPYTHON
  12 #define SWIG_PYTHON_NO_BUILD_NONE
  13 /* -----------------------------------------------------------------------------
  14  *  This section contains generic SWIG labels for method/variable
  15  *  declarations/attributes, and other compiler dependent labels.
  16  * ----------------------------------------------------------------------------- */
  17
  18 /* template workaround for compilers that cannot correctly implement the C++ standard */
  19 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  20 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  21 #  define SWIGTEMPLATEDISAMBIGUATOR template
  22 # elif defined(__HP_aCC)
  23 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  24 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  25 #  define SWIGTEMPLATEDISAMBIGUATOR template
  26 # else
  27 #  define SWIGTEMPLATEDISAMBIGUATOR
  28 # endif
  29 #endif
  30
  31 /* inline attribute */
  32 #ifndef SWIGINLINE
  33 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  34 #   define SWIGINLINE inline
  35 # else
  36 #   define SWIGINLINE
  37 # endif
  38 #endif
  39
  40 /* attribute recognised by some compilers to avoid 'unused' warnings */
  41 #ifndef SWIGUNUSED
  42 # if defined(__GNUC__)
  43 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  44 #     define SWIGUNUSED __attribute__ ((__unused__))
  45 #   else
  46 #     define SWIGUNUSED
  47 #   endif
  48 # elif defined(__ICC)
  49 #   define SWIGUNUSED __attribute__ ((__unused__))
  50 # else
  51 #   define SWIGUNUSED
  52 # endif
  53 #endif
  54
  55 #ifndef SWIGUNUSEDPARM
  56 # ifdef __cplusplus
  57 #   define SWIGUNUSEDPARM(p)
  58 # else
  59 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  60 # endif
  61 #endif
  62
  63 /* internal SWIG method */
  64 #ifndef SWIGINTERN
  65 # define SWIGINTERN static SWIGUNUSED
  66 #endif
  67
  68 /* internal inline SWIG method */
  69 #ifndef SWIGINTERNINLINE
  70 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  71 #endif
  72
  73 /* exporting methods */
  74 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  75 #  ifndef GCC_HASCLASSVISIBILITY
  76 #    define GCC_HASCLASSVISIBILITY
  77 #  endif
  78 #endif
  79
  80 #ifndef SWIGEXPORT
  81 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  82 #   if defined(STATIC_LINKED)
  83 #     define SWIGEXPORT
  84 #   else
  85 #     define SWIGEXPORT __declspec(dllexport)
  86 #   endif
  87 # else
  88 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
  89 #     define SWIGEXPORT __attribute__ ((visibility("default")))
  90 #   else
  91 #     define SWIGEXPORT
  92 #   endif
  93 # endif
  94 #endif
  95
  96 /* calling conventions for Windows */
  97 #ifndef SWIGSTDCALL
  98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  99 #   define SWIGSTDCALL __stdcall
 100 # else
 101 #   define SWIGSTDCALL
 102 # endif
 103 #endif
 104
 105 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 106 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 107 # define _CRT_SECURE_NO_DEPRECATE
 108 #endif
 109
 110 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 111 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 112 # define _SCL_SECURE_NO_DEPRECATE
 113 #endif
 114
 115
 116
 117 /* Python.h has to appear first */
 118 #include <Python.h>
 119
 120 /* -----------------------------------------------------------------------------
 121  * swigrun.swg
 122  *
 123  * This file contains generic CAPI SWIG runtime support for pointer
 124  * type checking.
 125  * ----------------------------------------------------------------------------- */
 126
 127 /* This should only be incremented when either the layout of swig_type_info changes,
 128    or for whatever reason, the runtime changes incompatibly */
 129 #define SWIG_RUNTIME_VERSION "4"
 130
 131 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 132 #ifdef SWIG_TYPE_TABLE
 133 # define SWIG_QUOTE_STRING(x) #x
 134 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 135 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 136 #else
 137 # define SWIG_TYPE_TABLE_NAME
 138 #endif
 139
 140 /*
 141   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 142   creating a static or dynamic library from the swig runtime code.
 143   In 99.9% of the cases, swig just needs to declare them as 'static'.
 144
 145   But only do this if is strictly necessary, ie, if you have problems
 146   with your compiler or so.
 147 */
 148
 149 #ifndef SWIGRUNTIME
 150 # define SWIGRUNTIME SWIGINTERN
 151 #endif
 152
 153 #ifndef SWIGRUNTIMEINLINE
 154 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 155 #endif
 156
 157 /*  Generic buffer size */
 158 #ifndef SWIG_BUFFER_SIZE
 159 # define SWIG_BUFFER_SIZE 1024
 160 #endif
 161
 162 /* Flags for pointer conversions */
 163 #define SWIG_POINTER_DISOWN        0x1
 164 #define SWIG_CAST_NEW_MEMORY       0x2
 165
 166 /* Flags for new pointer objects */
 167 #define SWIG_POINTER_OWN           0x1
 168
 169
 170 /*
 171    Flags/methods for returning states.
 172
 173    The swig conversion methods, as ConvertPtr, return and integer
 174    that tells if the conversion was successful or not. And if not,
 175    an error code can be returned (see swigerrors.swg for the codes).
 176
 177    Use the following macros/flags to set or process the returning
 178    states.
 179
 180    In old swig versions, you usually write code as:
 181
 182      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 183        // success code
 184      } else {
 185        //fail code
 186      }
 187
 188    Now you can be more explicit as:
 189
 190     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 191     if (SWIG_IsOK(res)) {
 192       // success code
 193     } else {
 194       // fail code
 195     }
 196
 197    that seems to be the same, but now you can also do
 198
 199     Type *ptr;
 200     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 201     if (SWIG_IsOK(res)) {
 202       // success code
 203       if (SWIG_IsNewObj(res) {
 204         ...
 205         delete *ptr;
 206       } else {
 207         ...
 208       }
 209     } else {
 210       // fail code
 211     }
 212
 213    I.e., now SWIG_ConvertPtr can return new objects and you can
 214    identify the case and take care of the deallocation. Of course that
 215    requires also to SWIG_ConvertPtr to return new result values, as
 216
 217       int SWIG_ConvertPtr(obj, ptr,...) {
 218         if (<obj is ok>) {
 219           if (<need new object>) {
 220             *ptr = <ptr to new allocated object>;
 221             return SWIG_NEWOBJ;
 222           } else {
 223             *ptr = <ptr to old object>;
 224             return SWIG_OLDOBJ;
 225           }
 226         } else {
 227           return SWIG_BADOBJ;
 228         }
 229       }
 230
 231    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 232    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 233    swig errors code.
 234
 235    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 236    allows to return the 'cast rank', for example, if you have this
 237
 238        int food(double)
 239        int fooi(int);
 240
 241    and you call
 242
 243       food(1)   // cast rank '1'  (1 -> 1.0)
 244       fooi(1)   // cast rank '0'
 245
 246    just use the SWIG_AddCast()/SWIG_CheckState()
 247
 248
 249  */
 250 #define SWIG_OK                    (0)
 251 #define SWIG_ERROR                 (-1)
 252 #define SWIG_IsOK(r)               (r >= 0)
 253 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 254
 255 /* The CastRankLimit says how many bits are used for the cast rank */
 256 #define SWIG_CASTRANKLIMIT         (1 << 8)
 257 /* The NewMask denotes the object was created (using new/malloc) */
 258 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 259 /* The TmpMask is for in/out typemaps that use temporal objects */
 260 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 261 /* Simple returning values */
 262 #define SWIG_BADOBJ                (SWIG_ERROR)
 263 #define SWIG_OLDOBJ                (SWIG_OK)
 264 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 265 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 266 /* Check, add and del mask methods */
 267 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 268 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 269 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 270 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 271 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 272 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 273
 274
 275 /* Cast-Rank Mode */
 276 #if defined(SWIG_CASTRANK_MODE)
 277 #  ifndef SWIG_TypeRank
 278 #    define SWIG_TypeRank             unsigned long
 279 #  endif
 280 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 281 #    define SWIG_MAXCASTRANK          (2)
 282 #  endif
 283 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 284 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 285 SWIGINTERNINLINE int SWIG_AddCast(int r) {
 286   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 287 }
 288 SWIGINTERNINLINE int SWIG_CheckState(int r) {
 289   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
 290 }
 291 #else /* no cast-rank mode */
 292 #  define SWIG_AddCast
 293 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 294 #endif
 295
 296
 297
 298
 299 #include <string.h>
 300
 301 #ifdef __cplusplus
 302 extern "C" {
 303 #endif
 304
 305 typedef void *(*swig_converter_func)(void *, int *);
 306 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 307
 308 /* Structure to store information on one type */
 309 typedef struct swig_type_info {
 310   const char             *name;                 /* mangled name of this type */
 311   const char             *str;                  /* human readable name of this type */
 312   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 313   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 314   void                   *clientdata;           /* language specific type data */
 315   int                    owndata;               /* flag if the structure owns the clientdata */
 316 } swig_type_info;
 317
 318 /* Structure to store a type and conversion function used for casting */
 319 typedef struct swig_cast_info {
 320   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 321   swig_converter_func     converter;            /* function to cast the void pointers */
 322   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 323   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 324 } swig_cast_info;
 325
 326 /* Structure used to store module information
 327  * Each module generates one structure like this, and the runtime collects
 328  * all of these structures and stores them in a circularly linked list.*/
 329 typedef struct swig_module_info {
 330   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 331   size_t                 size;                  /* Number of types in this module */
 332   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 333   swig_type_info         **type_initial;        /* Array of initially generated type structures */
 334   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 335   void                    *clientdata;          /* Language specific module data */
 336 } swig_module_info;
 337
 338 /*
 339   Compare two type names skipping the space characters, therefore
 340   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 341
 342   Return 0 when the two name types are equivalent, as in
 343   strncmp, but skipping ' '.
 344 */
 345 SWIGRUNTIME int
 346 SWIG_TypeNameComp(const char *f1, const char *l1,
 347                   const char *f2, const char *l2) {
 348   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 349     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 350     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 351     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 352   }
 353   return (int)((l1 - f1) - (l2 - f2));
 354 }
 355
 356 /*
 357   Check type equivalence in a name list like <name1>|<name2>|...
 358   Return 0 if not equal, 1 if equal
 359 */
 360 SWIGRUNTIME int
 361 SWIG_TypeEquiv(const char *nb, const char *tb) {
 362   int equiv = 0;
 363   const char* te = tb + strlen(tb);
 364   const char* ne = nb;
 365   while (!equiv && *ne) {
 366     for (nb = ne; *ne; ++ne) {
 367       if (*ne == '|') break;
 368     }
 369     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 370     if (*ne) ++ne;
 371   }
 372   return equiv;
 373 }
 374
 375 /*
 376   Check type equivalence in a name list like <name1>|<name2>|...
 377   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 378 */
 379 SWIGRUNTIME int
 380 SWIG_TypeCompare(const char *nb, const char *tb) {
 381   int equiv = 0;
 382   const char* te = tb + strlen(tb);
 383   const char* ne = nb;
 384   while (!equiv && *ne) {
 385     for (nb = ne; *ne; ++ne) {
 386       if (*ne == '|') break;
 387     }
 388     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 389     if (*ne) ++ne;
 390   }
 391   return equiv;
 392 }
 393
 394
 395 /* think of this as a c++ template<> or a scheme macro */
 396 #define SWIG_TypeCheck_Template(comparison, ty)         \
 397   if (ty) {                                             \
 398     swig_cast_info *iter = ty->cast;                    \
 399     while (iter) {                                      \
 400       if (comparison) {                                 \
 401         if (iter == ty->cast) return iter;              \
 402         /* Move iter to the top of the linked list */   \
 403         iter->prev->next = iter->next;                  \
 404         if (iter->next)                                 \
 405           iter->next->prev = iter->prev;                \
 406         iter->next = ty->cast;                          \
 407         iter->prev = 0;                                 \
 408         if (ty->cast) ty->cast->prev = iter;            \
 409         ty->cast = iter;                                \
 410         return iter;                                    \
 411       }                                                 \
 412       iter = iter->next;                                \
 413     }                                                   \
 414   }                                                     \
 415   return 0
 416
 417 /*
 418   Check the typename
 419 */
 420 SWIGRUNTIME swig_cast_info *
 421 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 422   SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 423 }
 424
 425 /* Same as previous function, except strcmp is replaced with a pointer comparison */
 426 SWIGRUNTIME swig_cast_info *
 427 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
 428   SWIG_TypeCheck_Template(iter->type == from, into);
 429 }
 430
 431 /*
 432   Cast a pointer up an inheritance hierarchy
 433 */
 434 SWIGRUNTIMEINLINE void *
 435 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
 436   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 437 }
 438
 439 /*
 440    Dynamic pointer casting. Down an inheritance hierarchy
 441 */
 442 SWIGRUNTIME swig_type_info *
 443 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 444   swig_type_info *lastty = ty;
 445   if (!ty || !ty->dcast) return ty;
 446   while (ty && (ty->dcast)) {
 447     ty = (*ty->dcast)(ptr);
 448     if (ty) lastty = ty;
 449   }
 450   return lastty;
 451 }
 452
 453 /*
 454   Return the name associated with this type
 455 */
 456 SWIGRUNTIMEINLINE const char *
 457 SWIG_TypeName(const swig_type_info *ty) {
 458   return ty->name;
 459 }
 460
 461 /*
 462   Return the pretty name associated with this type,
 463   that is an unmangled type name in a form presentable to the user.
 464 */
 465 SWIGRUNTIME const char *
 466 SWIG_TypePrettyName(const swig_type_info *type) {
 467   /* The "str" field contains the equivalent pretty names of the
 468      type, separated by vertical-bar characters.  We choose
 469      to print the last name, as it is often (?) the most
 470      specific. */
 471   if (!type) return NULL;
 472   if (type->str != NULL) {
 473     const char *last_name = type->str;
 474     const char *s;
 475     for (s = type->str; *s; s++)
 476       if (*s == '|') last_name = s+1;
 477     return last_name;
 478   }
 479   else
 480     return type->name;
 481 }
 482
 483 /*
 484    Set the clientdata field for a type
 485 */
 486 SWIGRUNTIME void
 487 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 488   swig_cast_info *cast = ti->cast;
 489   /* if (ti->clientdata == clientdata) return; */
 490   ti->clientdata = clientdata;
 491
 492   while (cast) {
 493     if (!cast->converter) {
 494       swig_type_info *tc = cast->type;
 495       if (!tc->clientdata) {
 496         SWIG_TypeClientData(tc, clientdata);
 497       }
 498     }
 499     cast = cast->next;
 500   }
 501 }
 502 SWIGRUNTIME void
 503 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 504   SWIG_TypeClientData(ti, clientdata);
 505   ti->owndata = 1;
 506 }
 507
 508 /*
 509   Search for a swig_type_info structure only by mangled name
 510   Search is a O(log #types)
 511
 512   We start searching at module start, and finish searching when start == end.
 513   Note: if start == end at the beginning of the function, we go all the way around
 514   the circular list.
 515 */
 516 SWIGRUNTIME swig_type_info *
 517 SWIG_MangledTypeQueryModule(swig_module_info *start,
 518                             swig_module_info *end,
 519                             const char *name) {
 520   swig_module_info *iter = start;
 521   do {
 522     if (iter->size) {
 523       register size_t l = 0;
 524       register size_t r = iter->size - 1;
 525       do {
 526         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 527         register size_t i = (l + r) >> 1;
 528         const char *iname = iter->types[i]->name;
 529         if (iname) {
 530           register int compare = strcmp(name, iname);
 531           if (compare == 0) {
 532             return iter->types[i];
 533           } else if (compare < 0) {
 534             if (i) {
 535               r = i - 1;
 536             } else {
 537               break;
 538             }
 539           } else if (compare > 0) {
 540             l = i + 1;
 541           }
 542         } else {
 543           break; /* should never happen */
 544         }
 545       } while (l <= r);
 546     }
 547     iter = iter->next;
 548   } while (iter != end);
 549   return 0;
 550 }
 551
 552 /*
 553   Search for a swig_type_info structure for either a mangled name or a human readable name.
 554   It first searches the mangled names of the types, which is a O(log #types)
 555   If a type is not found it then searches the human readable names, which is O(#types).
 556
 557   We start searching at module start, and finish searching when start == end.
 558   Note: if start == end at the beginning of the function, we go all the way around
 559   the circular list.
 560 */
 561 SWIGRUNTIME swig_type_info *
 562 SWIG_TypeQueryModule(swig_module_info *start,
 563                      swig_module_info *end,
 564                      const char *name) {
 565   /* STEP 1: Search the name field using binary search */
 566   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 567   if (ret) {
 568     return ret;
 569   } else {
 570     /* STEP 2: If the type hasn't been found, do a complete search
 571        of the str field (the human readable name) */
 572     swig_module_info *iter = start;
 573     do {
 574       register size_t i = 0;
 575       for (; i < iter->size; ++i) {
 576         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 577           return iter->types[i];
 578       }
 579       iter = iter->next;
 580     } while (iter != end);
 581   }
 582
 583   /* neither found a match */
 584   return 0;
 585 }
 586
 587 /*
 588    Pack binary data into a string
 589 */
 590 SWIGRUNTIME char *
 591 SWIG_PackData(char *c, void *ptr, size_t sz) {
 592   static const char hex[17] = "0123456789abcdef";
 593   register const unsigned char *u = (unsigned char *) ptr;
 594   register const unsigned char *eu =  u + sz;
 595   for (; u != eu; ++u) {
 596     register unsigned char uu = *u;
 597     *(c++) = hex[(uu & 0xf0) >> 4];
 598     *(c++) = hex[uu & 0xf];
 599   }
 600   return c;
 601 }
 602
 603 /*
 604    Unpack binary data from a string
 605 */
 606 SWIGRUNTIME const char *
 607 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 608   register unsigned char *u = (unsigned char *) ptr;
 609   register const unsigned char *eu = u + sz;
 610   for (; u != eu; ++u) {
 611     register char d = *(c++);
 612     register unsigned char uu;
 613     if ((d >= '0') && (d <= '9'))
 614       uu = ((d - '0') << 4);
 615     else if ((d >= 'a') && (d <= 'f'))
 616       uu = ((d - ('a'-10)) << 4);
 617     else
 618       return (char *) 0;
 619     d = *(c++);
 620     if ((d >= '0') && (d <= '9'))
 621       uu |= (d - '0');
 622     else if ((d >= 'a') && (d <= 'f'))
 623       uu |= (d - ('a'-10));
 624     else
 625       return (char *) 0;
 626     *u = uu;
 627   }
 628   return c;
 629 }
 630
 631 /*
 632    Pack 'void *' into a string buffer.
 633 */
 634 SWIGRUNTIME char *
 635 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 636   char *r = buff;
 637   if ((2*sizeof(void *) + 2) > bsz) return 0;
 638   *(r++) = '_';
 639   r = SWIG_PackData(r,&ptr,sizeof(void *));
 640   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 641   strcpy(r,name);
 642   return buff;
 643 }
 644
 645 SWIGRUNTIME const char *
 646 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 647   if (*c != '_') {
 648     if (strcmp(c,"NULL") == 0) {
 649       *ptr = (void *) 0;
 650       return name;
 651     } else {
 652       return 0;
 653     }
 654   }
 655   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 656 }
 657
 658 SWIGRUNTIME char *
 659 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 660   char *r = buff;
 661   size_t lname = (name ? strlen(name) : 0);
 662   if ((2*sz + 2 + lname) > bsz) return 0;
 663   *(r++) = '_';
 664   r = SWIG_PackData(r,ptr,sz);
 665   if (lname) {
 666     strncpy(r,name,lname+1);
 667   } else {
 668     *r = 0;
 669   }
 670   return buff;
 671 }
 672
 673 SWIGRUNTIME const char *
 674 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 675   if (*c != '_') {
 676     if (strcmp(c,"NULL") == 0) {
 677       memset(ptr,0,sz);
 678       return name;
 679     } else {
 680       return 0;
 681     }
 682   }
 683   return SWIG_UnpackData(++c,ptr,sz);
 684 }
 685
 686 #ifdef __cplusplus
 687 }
 688 #endif
 689
 690 /*  Errors in SWIG */
 691 #define  SWIG_UnknownError         -1
 692 #define  SWIG_IOError              -2
 693 #define  SWIG_RuntimeError         -3
 694 #define  SWIG_IndexError           -4
 695 #define  SWIG_TypeError            -5
 696 #define  SWIG_DivisionByZero       -6
 697 #define  SWIG_OverflowError        -7
 698 #define  SWIG_SyntaxError          -8
 699 #define  SWIG_ValueError           -9
 700 #define  SWIG_SystemError          -10
 701 #define  SWIG_AttributeError       -11
 702 #define  SWIG_MemoryError          -12
 703 #define  SWIG_NullReferenceError   -13
 704
 705
 706
 707
 708 /* Add PyOS_snprintf for old Pythons */
 709 #if PY_VERSION_HEX < 0x02020000
 710 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
 711 #  define PyOS_snprintf _snprintf
 712 # else
 713 #  define PyOS_snprintf snprintf
 714 # endif
 715 #endif
 716
 717 /* A crude PyString_FromFormat implementation for old Pythons */
 718 #if PY_VERSION_HEX < 0x02020000
 719
 720 #ifndef SWIG_PYBUFFER_SIZE
 721 # define SWIG_PYBUFFER_SIZE 1024
 722 #endif
 723
 724 static PyObject *
 725 PyString_FromFormat(const char *fmt, ...) {
 726   va_list ap;
 727   char buf[SWIG_PYBUFFER_SIZE * 2];
 728   int res;
 729   va_start(ap, fmt);
 730   res = vsnprintf(buf, sizeof(buf), fmt, ap);
 731   va_end(ap);
 732   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
 733 }
 734 #endif
 735
 736 /* Add PyObject_Del for old Pythons */
 737 #if PY_VERSION_HEX < 0x01060000
 738 # define PyObject_Del(op) PyMem_DEL((op))
 739 #endif
 740 #ifndef PyObject_DEL
 741 # define PyObject_DEL PyObject_Del
 742 #endif
 743
 744 /* A crude PyExc_StopIteration exception for old Pythons */
 745 #if PY_VERSION_HEX < 0x02020000
 746 # ifndef PyExc_StopIteration
 747 #  define PyExc_StopIteration PyExc_RuntimeError
 748 # endif
 749 # ifndef PyObject_GenericGetAttr
 750 #  define PyObject_GenericGetAttr 0
 751 # endif
 752 #endif
 753 /* Py_NotImplemented is defined in 2.1 and up. */
 754 #if PY_VERSION_HEX < 0x02010000
 755 # ifndef Py_NotImplemented
 756 #  define Py_NotImplemented PyExc_RuntimeError
 757 # endif
 758 #endif
 759
 760
 761 /* A crude PyString_AsStringAndSize implementation for old Pythons */
 762 #if PY_VERSION_HEX < 0x02010000
 763 # ifndef PyString_AsStringAndSize
 764 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
 765 # endif
 766 #endif
 767
 768 /* PySequence_Size for old Pythons */
 769 #if PY_VERSION_HEX < 0x02000000
 770 # ifndef PySequence_Size
 771 #  define PySequence_Size PySequence_Length
 772 # endif
 773 #endif
 774
 775
 776 /* PyBool_FromLong for old Pythons */
 777 #if PY_VERSION_HEX < 0x02030000
 778 static
 779 PyObject *PyBool_FromLong(long ok)
 780 {
 781   PyObject *result = ok ? Py_True : Py_False;
 782   Py_INCREF(result);
 783   return result;
 784 }
 785 #endif
 786
 787 /* Py_ssize_t for old Pythons */
 788 /* This code is as recommended by: */
 789 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
 790 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
 791 typedef int Py_ssize_t;
 792 # define PY_SSIZE_T_MAX INT_MAX
 793 # define PY_SSIZE_T_MIN INT_MIN
 794 #endif
 795
 796 /* -----------------------------------------------------------------------------
 797  * error manipulation
 798  * ----------------------------------------------------------------------------- */
 799
 800 SWIGRUNTIME PyObject*
 801 SWIG_Python_ErrorType(int code) {
 802   PyObject* type = 0;
 803   switch(code) {
 804   case SWIG_MemoryError:
 805     type = PyExc_MemoryError;
 806     break;
 807   case SWIG_IOError:
 808     type = PyExc_IOError;
 809     break;
 810   case SWIG_RuntimeError:
 811     type = PyExc_RuntimeError;
 812     break;
 813   case SWIG_IndexError:
 814     type = PyExc_IndexError;
 815     break;
 816   case SWIG_TypeError:
 817     type = PyExc_TypeError;
 818     break;
 819   case SWIG_DivisionByZero:
 820     type = PyExc_ZeroDivisionError;
 821     break;
 822   case SWIG_OverflowError:
 823     type = PyExc_OverflowError;
 824     break;
 825   case SWIG_SyntaxError:
 826     type = PyExc_SyntaxError;
 827     break;
 828   case SWIG_ValueError:
 829     type = PyExc_ValueError;
 830     break;
 831   case SWIG_SystemError:
 832     type = PyExc_SystemError;
 833     break;
 834   case SWIG_AttributeError:
 835     type = PyExc_AttributeError;
 836     break;
 837   default:
 838     type = PyExc_RuntimeError;
 839   }
 840   return type;
 841 }
 842
 843
 844 SWIGRUNTIME void
 845 SWIG_Python_AddErrorMsg(const char* mesg)
 846 {
 847   PyObject *type = 0;
 848   PyObject *value = 0;
 849   PyObject *traceback = 0;
 850
 851   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
 852   if (value) {
 853     PyObject *old_str = PyObject_Str(value);
 854     PyErr_Clear();
 855     Py_XINCREF(type);
 856     PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
 857     Py_DECREF(old_str);
 858     Py_DECREF(value);
 859   } else {
 860     PyErr_SetString(PyExc_RuntimeError, mesg);
 861   }
 862 }
 863
 864
 865
 866 #if defined(SWIG_PYTHON_NO_THREADS)
 867 #  if defined(SWIG_PYTHON_THREADS)
 868 #    undef SWIG_PYTHON_THREADS
 869 #  endif
 870 #endif
 871 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
 872 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
 873 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
 874 #      define SWIG_PYTHON_USE_GIL
 875 #    endif
 876 #  endif
 877 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
 878 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
 879 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads()
 880 #    endif
 881 #    ifdef __cplusplus /* C++ code */
 882        class SWIG_Python_Thread_Block {
 883          bool status;
 884          PyGILState_STATE state;
 885        public:
 886          void end() { if (status) { PyGILState_Release(state); status = false;} }
 887          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
 888          ~SWIG_Python_Thread_Block() { end(); }
 889        };
 890        class SWIG_Python_Thread_Allow {
 891          bool status;
 892          PyThreadState *save;
 893        public:
 894          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
 895          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
 896          ~SWIG_Python_Thread_Allow() { end(); }
 897        };
 898 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
 899 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
 900 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
 901 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
 902 #    else /* C code */
 903 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
 904 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
 905 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
 906 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
 907 #    endif
 908 #  else /* Old thread way, not implemented, user must provide it */
 909 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
 910 #      define SWIG_PYTHON_INITIALIZE_THREADS
 911 #    endif
 912 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
 913 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 914 #    endif
 915 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
 916 #      define SWIG_PYTHON_THREAD_END_BLOCK
 917 #    endif
 918 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
 919 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 920 #    endif
 921 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
 922 #      define SWIG_PYTHON_THREAD_END_ALLOW
 923 #    endif
 924 #  endif
 925 #else /* No thread support */
 926 #  define SWIG_PYTHON_INITIALIZE_THREADS
 927 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 928 #  define SWIG_PYTHON_THREAD_END_BLOCK
 929 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 930 #  define SWIG_PYTHON_THREAD_END_ALLOW
 931 #endif
 932
 933 /* -----------------------------------------------------------------------------
 934  * Python API portion that goes into the runtime
 935  * ----------------------------------------------------------------------------- */
 936
 937 #ifdef __cplusplus
 938 extern "C" {
 939 #if 0
 940 } /* cc-mode */
 941 #endif
 942 #endif
 943
 944 /* -----------------------------------------------------------------------------
 945  * Constant declarations
 946  * ----------------------------------------------------------------------------- */
 947
 948 /* Constant Types */
 949 #define SWIG_PY_POINTER 4
 950 #define SWIG_PY_BINARY  5
 951
 952 /* Constant information structure */
 953 typedef struct swig_const_info {
 954   int type;
 955   char *name;
 956   long lvalue;
 957   double dvalue;
 958   void   *pvalue;
 959   swig_type_info **ptype;
 960 } swig_const_info;
 961
 962 #ifdef __cplusplus
 963 #if 0
 964 { /* cc-mode */
 965 #endif
 966 }
 967 #endif
 968
 969
 970 /* -----------------------------------------------------------------------------
 971  * See the LICENSE file for information on copyright, usage and redistribution
 972  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 973  *
 974  * pyrun.swg
 975  *
 976  * This file contains the runtime support for Python modules
 977  * and includes code for managing global variables and pointer
 978  * type checking.
 979  *
 980  * ----------------------------------------------------------------------------- */
 981
 982 /* Common SWIG API */
 983
 984 /* for raw pointers */
 985 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
 986 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
 987 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
 988 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
 989 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty)
 990 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
 991 #define swig_owntype                                    int
 992
 993 /* for raw packed data */
 994 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
 995 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
 996
 997 /* for class or struct pointers */
 998 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
 999 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
1000
1001 /* for C or C++ function pointers */
1002 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1003 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
1004
1005 /* for C++ member pointers, ie, member methods */
1006 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1007 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1008
1009
1010 /* Runtime API */
1011
1012 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1013 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1014 #define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
1015
1016 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
1017 #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg
1018 #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)
1019 #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1020 #define SWIG_fail                                       goto fail
1021
1022
1023 /* Runtime API implementation */
1024
1025 /* Error manipulation */
1026
1027 SWIGINTERN void
1028 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1029   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1030   PyErr_SetObject(errtype, obj);
1031   Py_DECREF(obj);
1032   SWIG_PYTHON_THREAD_END_BLOCK;
1033 }
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1037   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038   PyErr_SetString(errtype, (char *) msg);
1039   SWIG_PYTHON_THREAD_END_BLOCK;
1040 }
1041
1042 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1043
1044 /* Set a constant value */
1045
1046 SWIGINTERN void
1047 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1048   PyDict_SetItemString(d, (char*) name, obj);
1049   Py_DECREF(obj);
1050 }
1051
1052 /* Append a value to the result obj */
1053
1054 SWIGINTERN PyObject*
1055 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1056 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1057   if (!result) {
1058     result = obj;
1059   } else if (result == Py_None) {
1060     Py_DECREF(result);
1061     result = obj;
1062   } else {
1063     if (!PyList_Check(result)) {
1064       PyObject *o2 = result;
1065       result = PyList_New(1);
1066       PyList_SetItem(result, 0, o2);
1067     }
1068     PyList_Append(result,obj);
1069     Py_DECREF(obj);
1070   }
1071   return result;
1072 #else
1073   PyObject*   o2;
1074   PyObject*   o3;
1075   if (!result) {
1076     result = obj;
1077   } else if (result == Py_None) {
1078     Py_DECREF(result);
1079     result = obj;
1080   } else {
1081     if (!PyTuple_Check(result)) {
1082       o2 = result;
1083       result = PyTuple_New(1);
1084       PyTuple_SET_ITEM(result, 0, o2);
1085     }
1086     o3 = PyTuple_New(1);
1087     PyTuple_SET_ITEM(o3, 0, obj);
1088     o2 = result;
1089     result = PySequence_Concat(o2, o3);
1090     Py_DECREF(o2);
1091     Py_DECREF(o3);
1092   }
1093   return result;
1094 #endif
1095 }
1096
1097 /* Unpack the argument tuple */
1098
1099 SWIGINTERN int
1100 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1101 {
1102   if (!args) {
1103     if (!min && !max) {
1104       return 1;
1105     } else {
1106       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1107                    name, (min == max ? "" : "at least "), (int)min);
1108       return 0;
1109     }
1110   }
1111   if (!PyTuple_Check(args)) {
1112     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1113     return 0;
1114   } else {
1115     register Py_ssize_t l = PyTuple_GET_SIZE(args);
1116     if (l < min) {
1117       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1118                    name, (min == max ? "" : "at least "), (int)min, (int)l);
1119       return 0;
1120     } else if (l > max) {
1121       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122                    name, (min == max ? "" : "at most "), (int)max, (int)l);
1123       return 0;
1124     } else {
1125       register int i;
1126       for (i = 0; i < l; ++i) {
1127         objs[i] = PyTuple_GET_ITEM(args, i);
1128       }
1129       for (; l < max; ++l) {
1130         objs[l] = 0;
1131       }
1132       return i + 1;
1133     }
1134   }
1135 }
1136
1137 /* A functor is a function object with one single object argument */
1138 #if PY_VERSION_HEX >= 0x02020000
1139 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
1140 #else
1141 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
1142 #endif
1143
1144 /*
1145   Helper for static pointer initialization for both C and C++ code, for example
1146   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1147 */
1148 #ifdef __cplusplus
1149 #define SWIG_STATIC_POINTER(var)  var
1150 #else
1151 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1152 #endif
1153
1154 /* -----------------------------------------------------------------------------
1155  * Pointer declarations
1156  * ----------------------------------------------------------------------------- */
1157
1158 /* Flags for new pointer objects */
1159 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
1160 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1161
1162 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1163
1164 #ifdef __cplusplus
1165 extern "C" {
1166 #if 0
1167 } /* cc-mode */
1168 #endif
1169 #endif
1170
1171 /*  How to access Py_None */
1172 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1173 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
1174 #    ifndef SWIG_PYTHON_BUILD_NONE
1175 #      define SWIG_PYTHON_BUILD_NONE
1176 #    endif
1177 #  endif
1178 #endif
1179
1180 #ifdef SWIG_PYTHON_BUILD_NONE
1181 #  ifdef Py_None
1182 #   undef Py_None
1183 #   define Py_None SWIG_Py_None()
1184 #  endif
1185 SWIGRUNTIMEINLINE PyObject *
1186 _SWIG_Py_None(void)
1187 {
1188   PyObject *none = Py_BuildValue((char*)"");
1189   Py_DECREF(none);
1190   return none;
1191 }
1192 SWIGRUNTIME PyObject *
1193 SWIG_Py_None(void)
1194 {
1195   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1196   return none;
1197 }
1198 #endif
1199
1200 /* The python void return value */
1201
1202 SWIGRUNTIMEINLINE PyObject *
1203 SWIG_Py_Void(void)
1204 {
1205   PyObject *none = Py_None;
1206   Py_INCREF(none);
1207   return none;
1208 }
1209
1210 /* PySwigClientData */
1211
1212 typedef struct {
1213   PyObject *klass;
1214   PyObject *newraw;
1215   PyObject *newargs;
1216   PyObject *destroy;
1217   int delargs;
1218   int implicitconv;
1219 } PySwigClientData;
1220
1221 SWIGRUNTIMEINLINE int
1222 SWIG_Python_CheckImplicit(swig_type_info *ty)
1223 {
1224   PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1225   return data ? data->implicitconv : 0;
1226 }
1227
1228 SWIGRUNTIMEINLINE PyObject *
1229 SWIG_Python_ExceptionType(swig_type_info *desc) {
1230   PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1231   PyObject *klass = data ? data->klass : 0;
1232   return (klass ? klass : PyExc_RuntimeError);
1233 }
1234
1235
1236 SWIGRUNTIME PySwigClientData *
1237 PySwigClientData_New(PyObject* obj)
1238 {
1239   if (!obj) {
1240     return 0;
1241   } else {
1242     PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1243     /* the klass element */
1244     data->klass = obj;
1245     Py_INCREF(data->klass);
1246     /* the newraw method and newargs arguments used to create a new raw instance */
1247     if (PyClass_Check(obj)) {
1248       data->newraw = 0;
1249       data->newargs = obj;
1250       Py_INCREF(obj);
1251     } else {
1252 #if (PY_VERSION_HEX < 0x02020000)
1253       data->newraw = 0;
1254 #else
1255       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1256 #endif
1257       if (data->newraw) {
1258         Py_INCREF(data->newraw);
1259         data->newargs = PyTuple_New(1);
1260         PyTuple_SetItem(data->newargs, 0, obj);
1261       } else {
1262         data->newargs = obj;
1263       }
1264       Py_INCREF(data->newargs);
1265     }
1266     /* the destroy method, aka as the C++ delete method */
1267     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1268     if (PyErr_Occurred()) {
1269       PyErr_Clear();
1270       data->destroy = 0;
1271     }
1272     if (data->destroy) {
1273       int flags;
1274       Py_INCREF(data->destroy);
1275       flags = PyCFunction_GET_FLAGS(data->destroy);
1276 #ifdef METH_O
1277       data->delargs = !(flags & (METH_O));
1278 #else
1279       data->delargs = 0;
1280 #endif
1281     } else {
1282       data->delargs = 0;
1283     }
1284     data->implicitconv = 0;
1285     return data;
1286   }
1287 }
1288
1289 SWIGRUNTIME void
1290 PySwigClientData_Del(PySwigClientData* data)
1291 {
1292   Py_XDECREF(data->newraw);
1293   Py_XDECREF(data->newargs);
1294   Py_XDECREF(data->destroy);
1295 }
1296
1297 /* =============== PySwigObject =====================*/
1298
1299 typedef struct {
1300   PyObject_HEAD
1301   void *ptr;
1302   swig_type_info *ty;
1303   int own;
1304   PyObject *next;
1305 } PySwigObject;
1306
1307 SWIGRUNTIME PyObject *
1308 PySwigObject_long(PySwigObject *v)
1309 {
1310   return PyLong_FromVoidPtr(v->ptr);
1311 }
1312
1313 SWIGRUNTIME PyObject *
1314 PySwigObject_format(const char* fmt, PySwigObject *v)
1315 {
1316   PyObject *res = NULL;
1317   PyObject *args = PyTuple_New(1);
1318   if (args) {
1319     if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1320       PyObject *ofmt = PyString_FromString(fmt);
1321       if (ofmt) {
1322         res = PyString_Format(ofmt,args);
1323         Py_DECREF(ofmt);
1324       }
1325       Py_DECREF(args);
1326     }
1327   }
1328   return res;
1329 }
1330
1331 SWIGRUNTIME PyObject *
1332 PySwigObject_oct(PySwigObject *v)
1333 {
1334   return PySwigObject_format("%o",v);
1335 }
1336
1337 SWIGRUNTIME PyObject *
1338 PySwigObject_hex(PySwigObject *v)
1339 {
1340   return PySwigObject_format("%x",v);
1341 }
1342
1343 SWIGRUNTIME PyObject *
1344 #ifdef METH_NOARGS
1345 PySwigObject_repr(PySwigObject *v)
1346 #else
1347 PySwigObject_repr(PySwigObject *v, PyObject *args)
1348 #endif
1349 {
1350   const char *name = SWIG_TypePrettyName(v->ty);
1351   PyObject *hex = PySwigObject_hex(v);
1352   PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1353   Py_DECREF(hex);
1354   if (v->next) {
1355 #ifdef METH_NOARGS
1356     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1357 #else
1358     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1359 #endif
1360     PyString_ConcatAndDel(&repr,nrep);
1361   }
1362   return repr;
1363 }
1364
1365 SWIGRUNTIME int
1366 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1367 {
1368 #ifdef METH_NOARGS
1369   PyObject *repr = PySwigObject_repr(v);
1370 #else
1371   PyObject *repr = PySwigObject_repr(v, NULL);
1372 #endif
1373   if (repr) {
1374     fputs(PyString_AsString(repr), fp);
1375     Py_DECREF(repr);
1376     return 0;
1377   } else {
1378     return 1;
1379   }
1380 }
1381
1382 SWIGRUNTIME PyObject *
1383 PySwigObject_str(PySwigObject *v)
1384 {
1385   char result[SWIG_BUFFER_SIZE];
1386   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1387     PyString_FromString(result) : 0;
1388 }
1389
1390 SWIGRUNTIME int
1391 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1392 {
1393   void *i = v->ptr;
1394   void *j = w->ptr;
1395   return (i < j) ? -1 : ((i > j) ? 1 : 0);
1396 }
1397
1398 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1399
1400 SWIGRUNTIME PyTypeObject*
1401 PySwigObject_type(void) {
1402   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1403   return type;
1404 }
1405
1406 SWIGRUNTIMEINLINE int
1407 PySwigObject_Check(PyObject *op) {
1408   return ((op)->ob_type == PySwigObject_type())
1409     || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1410 }
1411
1412 SWIGRUNTIME PyObject *
1413 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1414
1415 SWIGRUNTIME void
1416 PySwigObject_dealloc(PyObject *v)
1417 {
1418   PySwigObject *sobj = (PySwigObject *) v;
1419   PyObject *next = sobj->next;
1420   if (sobj->own == SWIG_POINTER_OWN) {
1421     swig_type_info *ty = sobj->ty;
1422     PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1423     PyObject *destroy = data ? data->destroy : 0;
1424     if (destroy) {
1425       /* destroy is always a VARARGS method */
1426       PyObject *res;
1427       if (data->delargs) {
1428         /* we need to create a temporal object to carry the destroy operation */
1429         PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1430         res = SWIG_Python_CallFunctor(destroy, tmp);
1431         Py_DECREF(tmp);
1432       } else {
1433         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1434         PyObject *mself = PyCFunction_GET_SELF(destroy);
1435         res = ((*meth)(mself, v));
1436       }
1437       Py_XDECREF(res);
1438     }
1439 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1440     else {
1441       const char *name = SWIG_TypePrettyName(ty);
1442       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1443     }
1444 #endif
1445   }
1446   Py_XDECREF(next);
1447   PyObject_DEL(v);
1448 }
1449
1450 SWIGRUNTIME PyObject*
1451 PySwigObject_append(PyObject* v, PyObject* next)
1452 {
1453   PySwigObject *sobj = (PySwigObject *) v;
1454 #ifndef METH_O
1455   PyObject *tmp = 0;
1456   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1457   next = tmp;
1458 #endif
1459   if (!PySwigObject_Check(next)) {
1460     return NULL;
1461   }
1462   sobj->next = next;
1463   Py_INCREF(next);
1464   return SWIG_Py_Void();
1465 }
1466
1467 SWIGRUNTIME PyObject*
1468 #ifdef METH_NOARGS
1469 PySwigObject_next(PyObject* v)
1470 #else
1471 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1472 #endif
1473 {
1474   PySwigObject *sobj = (PySwigObject *) v;
1475   if (sobj->next) {
1476     Py_INCREF(sobj->next);
1477     return sobj->next;
1478   } else {
1479     return SWIG_Py_Void();
1480   }
1481 }
1482
1483 SWIGINTERN PyObject*
1484 #ifdef METH_NOARGS
1485 PySwigObject_disown(PyObject *v)
1486 #else
1487 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1488 #endif
1489 {
1490   PySwigObject *sobj = (PySwigObject *)v;
1491   sobj->own = 0;
1492   return SWIG_Py_Void();
1493 }
1494
1495 SWIGINTERN PyObject*
1496 #ifdef METH_NOARGS
1497 PySwigObject_acquire(PyObject *v)
1498 #else
1499 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1500 #endif
1501 {
1502   PySwigObject *sobj = (PySwigObject *)v;
1503   sobj->own = SWIG_POINTER_OWN;
1504   return SWIG_Py_Void();
1505 }
1506
1507 SWIGINTERN PyObject*
1508 PySwigObject_own(PyObject *v, PyObject *args)
1509 {
1510   PyObject *val = 0;
1511 #if (PY_VERSION_HEX < 0x02020000)
1512   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1513 #else
1514   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1515 #endif
1516     {
1517       return NULL;
1518     }
1519   else
1520     {
1521       PySwigObject *sobj = (PySwigObject *)v;
1522       PyObject *obj = PyBool_FromLong(sobj->own);
1523       if (val) {
1524 #ifdef METH_NOARGS
1525         if (PyObject_IsTrue(val)) {
1526           PySwigObject_acquire(v);
1527         } else {
1528           PySwigObject_disown(v);
1529         }
1530 #else
1531         if (PyObject_IsTrue(val)) {
1532           PySwigObject_acquire(v,args);
1533         } else {
1534           PySwigObject_disown(v,args);
1535         }
1536 #endif
1537       }
1538       return obj;
1539     }
1540 }
1541
1542 #ifdef METH_O
1543 static PyMethodDef
1544 swigobject_methods[] = {
1545   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1546   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
1547   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1548   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
1549   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1550   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1551   {0, 0, 0, 0}
1552 };
1553 #else
1554 static PyMethodDef
1555 swigobject_methods[] = {
1556   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1557   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1558   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1559   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1560   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1561   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1562   {0, 0, 0, 0}
1563 };
1564 #endif
1565
1566 #if PY_VERSION_HEX < 0x02020000
1567 SWIGINTERN PyObject *
1568 PySwigObject_getattr(PySwigObject *sobj,char *name)
1569 {
1570   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1571 }
1572 #endif
1573
1574 SWIGRUNTIME PyTypeObject*
1575 _PySwigObject_type(void) {
1576   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1577
1578   static PyNumberMethods PySwigObject_as_number = {
1579     (binaryfunc)0, /*nb_add*/
1580     (binaryfunc)0, /*nb_subtract*/
1581     (binaryfunc)0, /*nb_multiply*/
1582     (binaryfunc)0, /*nb_divide*/
1583     (binaryfunc)0, /*nb_remainder*/
1584     (binaryfunc)0, /*nb_divmod*/
1585     (ternaryfunc)0,/*nb_power*/
1586     (unaryfunc)0,  /*nb_negative*/
1587     (unaryfunc)0,  /*nb_positive*/
1588     (unaryfunc)0,  /*nb_absolute*/
1589     (inquiry)0,    /*nb_nonzero*/
1590     0,             /*nb_invert*/
1591     0,             /*nb_lshift*/
1592     0,             /*nb_rshift*/
1593     0,             /*nb_and*/
1594     0,             /*nb_xor*/
1595     0,             /*nb_or*/
1596     (coercion)0,   /*nb_coerce*/
1597     (unaryfunc)PySwigObject_long, /*nb_int*/
1598     (unaryfunc)PySwigObject_long, /*nb_long*/
1599     (unaryfunc)0,                 /*nb_float*/
1600     (unaryfunc)PySwigObject_oct,  /*nb_oct*/
1601     (unaryfunc)PySwigObject_hex,  /*nb_hex*/
1602 #if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1603     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1604 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1605     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1606 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1607     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1608 #endif
1609   };
1610
1611   static PyTypeObject pyswigobject_type;
1612   static int type_init = 0;
1613   if (!type_init) {
1614     const PyTypeObject tmp
1615       = {
1616         PyObject_HEAD_INIT(NULL)
1617         0,                                  /* ob_size */
1618         (char *)"PySwigObject",             /* tp_name */
1619         sizeof(PySwigObject),               /* tp_basicsize */
1620         0,                                  /* tp_itemsize */
1621         (destructor)PySwigObject_dealloc,   /* tp_dealloc */
1622         (printfunc)PySwigObject_print,      /* tp_print */
1623 #if PY_VERSION_HEX < 0x02020000
1624         (getattrfunc)PySwigObject_getattr,  /* tp_getattr */
1625 #else
1626         (getattrfunc)0,                     /* tp_getattr */
1627 #endif
1628         (setattrfunc)0,                     /* tp_setattr */
1629         (cmpfunc)PySwigObject_compare,      /* tp_compare */
1630         (reprfunc)PySwigObject_repr,        /* tp_repr */
1631         &PySwigObject_as_number,            /* tp_as_number */
1632         0,                                  /* tp_as_sequence */
1633         0,                                  /* tp_as_mapping */
1634         (hashfunc)0,                        /* tp_hash */
1635         (ternaryfunc)0,                     /* tp_call */
1636         (reprfunc)PySwigObject_str,         /* tp_str */
1637         PyObject_GenericGetAttr,            /* tp_getattro */
1638         0,                                  /* tp_setattro */
1639         0,                                  /* tp_as_buffer */
1640         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1641         swigobject_doc,                     /* tp_doc */
1642         0,                                  /* tp_traverse */
1643         0,                                  /* tp_clear */
1644         0,                                  /* tp_richcompare */
1645         0,                                  /* tp_weaklistoffset */
1646 #if PY_VERSION_HEX >= 0x02020000
1647         0,                                  /* tp_iter */
1648         0,                                  /* tp_iternext */
1649         swigobject_methods,                 /* tp_methods */
1650         0,                                  /* tp_members */
1651         0,                                  /* tp_getset */
1652         0,                                  /* tp_base */
1653         0,                                  /* tp_dict */
1654         0,                                  /* tp_descr_get */
1655         0,                                  /* tp_descr_set */
1656         0,                                  /* tp_dictoffset */
1657         0,                                  /* tp_init */
1658         0,                                  /* tp_alloc */
1659         0,                                  /* tp_new */
1660         0,                                  /* tp_free */
1661         0,                                  /* tp_is_gc */
1662         0,                                  /* tp_bases */
1663         0,                                  /* tp_mro */
1664         0,                                  /* tp_cache */
1665         0,                                  /* tp_subclasses */
1666         0,                                  /* tp_weaklist */
1667 #endif
1668 #if PY_VERSION_HEX >= 0x02030000
1669         0,                                  /* tp_del */
1670 #endif
1671 #ifdef COUNT_ALLOCS
1672         0,0,0,0                             /* tp_alloc -> tp_next */
1673 #endif
1674       };
1675     pyswigobject_type = tmp;
1676     pyswigobject_type.ob_type = &PyType_Type;
1677     type_init = 1;
1678   }
1679   return &pyswigobject_type;
1680 }
1681
1682 SWIGRUNTIME PyObject *
1683 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1684 {
1685   PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1686   if (sobj) {
1687     sobj->ptr  = ptr;
1688     sobj->ty   = ty;
1689     sobj->own  = own;
1690     sobj->next = 0;
1691   }
1692   return (PyObject *)sobj;
1693 }
1694
1695 /* -----------------------------------------------------------------------------
1696  * Implements a simple Swig Packed type, and use it instead of string
1697  * ----------------------------------------------------------------------------- */
1698
1699 typedef struct {
1700   PyObject_HEAD
1701   void *pack;
1702   swig_type_info *ty;
1703   size_t size;
1704 } PySwigPacked;
1705
1706 SWIGRUNTIME int
1707 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1708 {
1709   char result[SWIG_BUFFER_SIZE];
1710   fputs("<Swig Packed ", fp);
1711   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1712     fputs("at ", fp);
1713     fputs(result, fp);
1714   }
1715   fputs(v->ty->name,fp);
1716   fputs(">", fp);
1717   return 0;
1718 }
1719
1720 SWIGRUNTIME PyObject *
1721 PySwigPacked_repr(PySwigPacked *v)
1722 {
1723   char result[SWIG_BUFFER_SIZE];
1724   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1725     return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1726   } else {
1727     return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1728   }
1729 }
1730
1731 SWIGRUNTIME PyObject *
1732 PySwigPacked_str(PySwigPacked *v)
1733 {
1734   char result[SWIG_BUFFER_SIZE];
1735   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1736     return PyString_FromFormat("%s%s", result, v->ty->name);
1737   } else {
1738     return PyString_FromString(v->ty->name);
1739   }
1740 }
1741
1742 SWIGRUNTIME int
1743 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1744 {
1745   size_t i = v->size;
1746   size_t j = w->size;
1747   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1748   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1749 }
1750
1751 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1752
1753 SWIGRUNTIME PyTypeObject*
1754 PySwigPacked_type(void) {
1755   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1756   return type;
1757 }
1758
1759 SWIGRUNTIMEINLINE int
1760 PySwigPacked_Check(PyObject *op) {
1761   return ((op)->ob_type == _PySwigPacked_type())
1762     || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1763 }
1764
1765 SWIGRUNTIME void
1766 PySwigPacked_dealloc(PyObject *v)
1767 {
1768   if (PySwigPacked_Check(v)) {
1769     PySwigPacked *sobj = (PySwigPacked *) v;
1770     free(sobj->pack);
1771   }
1772   PyObject_DEL(v);
1773 }
1774
1775 SWIGRUNTIME PyTypeObject*
1776 _PySwigPacked_type(void) {
1777   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1778   static PyTypeObject pyswigpacked_type;
1779   static int type_init = 0;
1780   if (!type_init) {
1781     const PyTypeObject tmp
1782       = {
1783         PyObject_HEAD_INIT(NULL)
1784         0,                                  /* ob_size */
1785         (char *)"PySwigPacked",             /* tp_name */
1786         sizeof(PySwigPacked),               /* tp_basicsize */
1787         0,                                  /* tp_itemsize */
1788         (destructor)PySwigPacked_dealloc,   /* tp_dealloc */
1789         (printfunc)PySwigPacked_print,      /* tp_print */
1790         (getattrfunc)0,                     /* tp_getattr */
1791         (setattrfunc)0,                     /* tp_setattr */
1792         (cmpfunc)PySwigPacked_compare,      /* tp_compare */
1793         (reprfunc)PySwigPacked_repr,        /* tp_repr */
1794         0,                                  /* tp_as_number */
1795         0,                                  /* tp_as_sequence */
1796         0,                                  /* tp_as_mapping */
1797         (hashfunc)0,                        /* tp_hash */
1798         (ternaryfunc)0,                     /* tp_call */
1799         (reprfunc)PySwigPacked_str,         /* tp_str */
1800         PyObject_GenericGetAttr,            /* tp_getattro */
1801         0,                                  /* tp_setattro */
1802         0,                                  /* tp_as_buffer */
1803         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1804         swigpacked_doc,                     /* tp_doc */
1805         0,                                  /* tp_traverse */
1806         0,                                  /* tp_clear */
1807         0,                                  /* tp_richcompare */
1808         0,                                  /* tp_weaklistoffset */
1809 #if PY_VERSION_HEX >= 0x02020000
1810         0,                                  /* tp_iter */
1811         0,                                  /* tp_iternext */
1812         0,                                  /* tp_methods */
1813         0,                                  /* tp_members */
1814         0,                                  /* tp_getset */
1815         0,                                  /* tp_base */
1816         0,                                  /* tp_dict */
1817         0,                                  /* tp_descr_get */
1818         0,                                  /* tp_descr_set */
1819         0,                                  /* tp_dictoffset */
1820         0,                                  /* tp_init */
1821         0,                                  /* tp_alloc */
1822         0,                                  /* tp_new */
1823         0,                                  /* tp_free */
1824         0,                                  /* tp_is_gc */
1825         0,                                  /* tp_bases */
1826         0,                                  /* tp_mro */
1827         0,                                  /* tp_cache */
1828         0,                                  /* tp_subclasses */
1829         0,                                  /* tp_weaklist */
1830 #endif
1831 #if PY_VERSION_HEX >= 0x02030000
1832         0,                                  /* tp_del */
1833 #endif
1834 #ifdef COUNT_ALLOCS
1835         0,0,0,0                             /* tp_alloc -> tp_next */
1836 #endif
1837       };
1838     pyswigpacked_type = tmp;
1839     pyswigpacked_type.ob_type = &PyType_Type;
1840     type_init = 1;
1841   }
1842   return &pyswigpacked_type;
1843 }
1844
1845 SWIGRUNTIME PyObject *
1846 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1847 {
1848   PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1849   if (sobj) {
1850     void *pack = malloc(size);
1851     if (pack) {
1852       memcpy(pack, ptr, size);
1853       sobj->pack = pack;
1854       sobj->ty   = ty;
1855       sobj->size = size;
1856     } else {
1857       PyObject_DEL((PyObject *) sobj);
1858       sobj = 0;
1859     }
1860   }
1861   return (PyObject *) sobj;
1862 }
1863
1864 SWIGRUNTIME swig_type_info *
1865 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1866 {
1867   if (PySwigPacked_Check(obj)) {
1868     PySwigPacked *sobj = (PySwigPacked *)obj;
1869     if (sobj->size != size) return 0;
1870     memcpy(ptr, sobj->pack, size);
1871     return sobj->ty;
1872   } else {
1873     return 0;
1874   }
1875 }
1876
1877 /* -----------------------------------------------------------------------------
1878  * pointers/data manipulation
1879  * ----------------------------------------------------------------------------- */
1880
1881 SWIGRUNTIMEINLINE PyObject *
1882 _SWIG_This(void)
1883 {
1884   return PyString_FromString("this");
1885 }
1886
1887 SWIGRUNTIME PyObject *
1888 SWIG_This(void)
1889 {
1890   static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1891   return swig_this;
1892 }
1893
1894 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1895
1896 SWIGRUNTIME PySwigObject *
1897 SWIG_Python_GetSwigThis(PyObject *pyobj)
1898 {
1899   if (PySwigObject_Check(pyobj)) {
1900     return (PySwigObject *) pyobj;
1901   } else {
1902     PyObject *obj = 0;
1903 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1904     if (PyInstance_Check(pyobj)) {
1905       obj = _PyInstance_Lookup(pyobj, SWIG_This());
1906     } else {
1907       PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1908       if (dictptr != NULL) {
1909         PyObject *dict = *dictptr;
1910         obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1911       } else {
1912 #ifdef PyWeakref_CheckProxy
1913         if (PyWeakref_CheckProxy(pyobj)) {
1914           PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1915           return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1916         }
1917 #endif
1918         obj = PyObject_GetAttr(pyobj,SWIG_This());
1919         if (obj) {
1920           Py_DECREF(obj);
1921         } else {
1922           if (PyErr_Occurred()) PyErr_Clear();
1923           return 0;
1924         }
1925       }
1926     }
1927 #else
1928     obj = PyObject_GetAttr(pyobj,SWIG_This());
1929     if (obj) {
1930       Py_DECREF(obj);
1931     } else {
1932       if (PyErr_Occurred()) PyErr_Clear();
1933       return 0;
1934     }
1935 #endif
1936     if (obj && !PySwigObject_Check(obj)) {
1937       /* a PyObject is called 'this', try to get the 'real this'
1938          PySwigObject from it */
1939       return SWIG_Python_GetSwigThis(obj);
1940     }
1941     return (PySwigObject *)obj;
1942   }
1943 }
1944
1945 /* Acquire a pointer value */
1946
1947 SWIGRUNTIME int
1948 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1949   if (own == SWIG_POINTER_OWN) {
1950     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1951     if (sobj) {
1952       int oldown = sobj->own;
1953       sobj->own = own;
1954       return oldown;
1955     }
1956   }
1957   return 0;
1958 }
1959
1960 /* Convert a pointer value */
1961
1962 SWIGRUNTIME int
1963 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1964   if (!obj) return SWIG_ERROR;
1965   if (obj == Py_None) {
1966     if (ptr) *ptr = 0;
1967     return SWIG_OK;
1968   } else {
1969     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1970     if (own)
1971       *own = 0;
1972     while (sobj) {
1973       void *vptr = sobj->ptr;
1974       if (ty) {
1975         swig_type_info *to = sobj->ty;
1976         if (to == ty) {
1977           /* no type cast needed */
1978           if (ptr) *ptr = vptr;
1979           break;
1980         } else {
1981           swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1982           if (!tc) {
1983             sobj = (PySwigObject *)sobj->next;
1984           } else {
1985             if (ptr) {
1986               int newmemory = 0;
1987               *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
1988               if (newmemory == SWIG_CAST_NEW_MEMORY) {
1989                 assert(own);
1990                 if (own)
1991                   *own = *own | SWIG_CAST_NEW_MEMORY;
1992               }
1993             }
1994             break;
1995           }
1996         }
1997       } else {
1998         if (ptr) *ptr = vptr;
1999         break;
2000       }
2001     }
2002     if (sobj) {
2003       if (own)
2004         *own = *own | sobj->own;
2005       if (flags & SWIG_POINTER_DISOWN) {
2006         sobj->own = 0;
2007       }
2008       return SWIG_OK;
2009     } else {
2010       int res = SWIG_ERROR;
2011       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2012         PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2013         if (data && !data->implicitconv) {
2014           PyObject *klass = data->klass;
2015           if (klass) {
2016             PyObject *impconv;
2017             data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2018             impconv = SWIG_Python_CallFunctor(klass, obj);
2019             data->implicitconv = 0;
2020             if (PyErr_Occurred()) {
2021               PyErr_Clear();
2022               impconv = 0;
2023             }
2024             if (impconv) {
2025               PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2026               if (iobj) {
2027                 void *vptr;
2028                 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2029                 if (SWIG_IsOK(res)) {
2030                   if (ptr) {
2031                     *ptr = vptr;
2032                     /* transfer the ownership to 'ptr' */
2033                     iobj->own = 0;
2034                     res = SWIG_AddCast(res);
2035                     res = SWIG_AddNewMask(res);
2036                   } else {
2037                     res = SWIG_AddCast(res);
2038                   }
2039                 }
2040               }
2041               Py_DECREF(impconv);
2042             }
2043           }
2044         }
2045       }
2046       return res;
2047     }
2048   }
2049 }
2050
2051 /* Convert a function ptr value */
2052
2053 SWIGRUNTIME int
2054 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2055   if (!PyCFunction_Check(obj)) {
2056     return SWIG_ConvertPtr(obj, ptr, ty, 0);
2057   } else {
2058     void *vptr = 0;
2059
2060     /* here we get the method pointer for callbacks */
2061     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2062     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2063     if (desc) {
2064       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2065       if (!desc) return SWIG_ERROR;
2066     }
2067     if (ty) {
2068       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2069       if (tc) {
2070         int newmemory = 0;
2071         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2072         assert(!newmemory); /* newmemory handling not yet implemented */
2073       } else {
2074         return SWIG_ERROR;
2075       }
2076     } else {
2077       *ptr = vptr;
2078     }
2079     return SWIG_OK;
2080   }
2081 }
2082
2083 /* Convert a packed value value */
2084
2085 SWIGRUNTIME int
2086 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2087   swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2088   if (!to) return SWIG_ERROR;
2089   if (ty) {
2090     if (to != ty) {
2091       /* check type cast? */
2092       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2093       if (!tc) return SWIG_ERROR;
2094     }
2095   }
2096   return SWIG_OK;
2097 }
2098
2099 /* -----------------------------------------------------------------------------
2100  * Create a new pointer object
2101  * ----------------------------------------------------------------------------- */
2102
2103 /*
2104   Create a new instance object, whitout calling __init__, and set the
2105   'this' attribute.
2106 */
2107
2108 SWIGRUNTIME PyObject*
2109 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2110 {
2111 #if (PY_VERSION_HEX >= 0x02020000)
2112   PyObject *inst = 0;
2113   PyObject *newraw = data->newraw;
2114   if (newraw) {
2115     inst = PyObject_Call(newraw, data->newargs, NULL);
2116     if (inst) {
2117 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2118       PyObject **dictptr = _PyObject_GetDictPtr(inst);
2119       if (dictptr != NULL) {
2120         PyObject *dict = *dictptr;
2121         if (dict == NULL) {
2122           dict = PyDict_New();
2123           *dictptr = dict;
2124           PyDict_SetItem(dict, SWIG_This(), swig_this);
2125         }
2126       }
2127 #else
2128       PyObject *key = SWIG_This();
2129       PyObject_SetAttr(inst, key, swig_this);
2130 #endif
2131     }
2132   } else {
2133     PyObject *dict = PyDict_New();
2134     PyDict_SetItem(dict, SWIG_This(), swig_this);
2135     inst = PyInstance_NewRaw(data->newargs, dict);
2136     Py_DECREF(dict);
2137   }
2138   return inst;
2139 #else
2140 #if (PY_VERSION_HEX >= 0x02010000)
2141   PyObject *inst;
2142   PyObject *dict = PyDict_New();
2143   PyDict_SetItem(dict, SWIG_This(), swig_this);
2144   inst = PyInstance_NewRaw(data->newargs, dict);
2145   Py_DECREF(dict);
2146   return (PyObject *) inst;
2147 #else
2148   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2149   if (inst == NULL) {
2150     return NULL;
2151   }
2152   inst->in_class = (PyClassObject *)data->newargs;
2153   Py_INCREF(inst->in_class);
2154   inst->in_dict = PyDict_New();
2155   if (inst->in_dict == NULL) {
2156     Py_DECREF(inst);
2157     return NULL;
2158   }
2159 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2160   inst->in_weakreflist = NULL;
2161 #endif
2162 #ifdef Py_TPFLAGS_GC
2163   PyObject_GC_Init(inst);
2164 #endif
2165   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2166   return (PyObject *) inst;
2167 #endif
2168 #endif
2169 }
2170
2171 SWIGRUNTIME void
2172 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2173 {
2174  PyObject *dict;
2175 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2176  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2177  if (dictptr != NULL) {
2178    dict = *dictptr;
2179    if (dict == NULL) {
2180      dict = PyDict_New();
2181      *dictptr = dict;
2182    }
2183    PyDict_SetItem(dict, SWIG_This(), swig_this);
2184    return;
2185  }
2186 #endif
2187  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2188  PyDict_SetItem(dict, SWIG_This(), swig_this);
2189  Py_DECREF(dict);
2190 }
2191
2192
2193 SWIGINTERN PyObject *
2194 SWIG_Python_InitShadowInstance(PyObject *args) {
2195   PyObject *obj[2];
2196   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2197     return NULL;
2198   } else {
2199     PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2200     if (sthis) {
2201       PySwigObject_append((PyObject*) sthis, obj[1]);
2202     } else {
2203       SWIG_Python_SetSwigThis(obj[0], obj[1]);
2204     }
2205     return SWIG_Py_Void();
2206   }
2207 }
2208
2209 /* Create a new pointer object */
2210
2211 SWIGRUNTIME PyObject *
2212 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2213   if (!ptr) {
2214     return SWIG_Py_Void();
2215   } else {
2216     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2217     PyObject *robj = PySwigObject_New(ptr, type, own);
2218     PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2219     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2220       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2221       if (inst) {
2222         Py_DECREF(robj);
2223         robj = inst;
2224       }
2225     }
2226     return robj;
2227   }
2228 }
2229
2230 /* Create a new packed object */
2231
2232 SWIGRUNTIMEINLINE PyObject *
2233 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2234   return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2235 }
2236
2237 /* -----------------------------------------------------------------------------*
2238  *  Get type list
2239  * -----------------------------------------------------------------------------*/
2240
2241 #ifdef SWIG_LINK_RUNTIME
2242 void *SWIG_ReturnGlobalTypeList(void *);
2243 #endif
2244
2245 SWIGRUNTIME swig_module_info *
2246 SWIG_Python_GetModule(void) {
2247   static void *type_pointer = (void *)0;
2248   /* first check if module already created */
2249   if (!type_pointer) {
2250 #ifdef SWIG_LINK_RUNTIME
2251     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2252 #else
2253     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2254                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2255     if (PyErr_Occurred()) {
2256       PyErr_Clear();
2257       type_pointer = (void *)0;
2258     }
2259 #endif
2260   }
2261   return (swig_module_info *) type_pointer;
2262 }
2263
2264 #if PY_MAJOR_VERSION < 2
2265 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
2266    is copied out of Python/modsupport.c in python version 2.3.4 */
2267 SWIGINTERN int
2268 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2269 {
2270   PyObject *dict;
2271   if (!PyModule_Check(m)) {
2272     PyErr_SetString(PyExc_TypeError,
2273                     "PyModule_AddObject() needs module as first arg");
2274     return SWIG_ERROR;
2275   }
2276   if (!o) {
2277     PyErr_SetString(PyExc_TypeError,
2278                     "PyModule_AddObject() needs non-NULL value");
2279     return SWIG_ERROR;
2280   }
2281
2282   dict = PyModule_GetDict(m);
2283   if (dict == NULL) {
2284     /* Internal error -- modules must have a dict! */
2285     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2286                  PyModule_GetName(m));
2287     return SWIG_ERROR;
2288   }
2289   if (PyDict_SetItemString(dict, name, o))
2290     return SWIG_ERROR;
2291   Py_DECREF(o);
2292   return SWIG_OK;
2293 }
2294 #endif
2295
2296 SWIGRUNTIME void
2297 SWIG_Python_DestroyModule(void *vptr)
2298 {
2299   swig_module_info *swig_module = (swig_module_info *) vptr;
2300   swig_type_info **types = swig_module->types;
2301   size_t i;
2302   for (i =0; i < swig_module->size; ++i) {
2303     swig_type_info *ty = types[i];
2304     if (ty->owndata) {
2305       PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2306       if (data) PySwigClientData_Del(data);
2307     }
2308   }
2309   Py_DECREF(SWIG_This());
2310 }
2311
2312 SWIGRUNTIME void
2313 SWIG_Python_SetModule(swig_module_info *swig_module) {
2314   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2315
2316   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2317                                    swig_empty_runtime_method_table);
2318   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2319   if (pointer && module) {
2320     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2321   } else {
2322     Py_XDECREF(pointer);
2323   }
2324 }
2325
2326 /* The python cached type query */
2327 SWIGRUNTIME PyObject *
2328 SWIG_Python_TypeCache(void) {
2329   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2330   return cache;
2331 }
2332
2333 SWIGRUNTIME swig_type_info *
2334 SWIG_Python_TypeQuery(const char *type)
2335 {
2336   PyObject *cache = SWIG_Python_TypeCache();
2337   PyObject *key = PyString_FromString(type);
2338   PyObject *obj = PyDict_GetItem(cache, key);
2339   swig_type_info *descriptor;
2340   if (obj) {
2341     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2342   } else {
2343     swig_module_info *swig_module = SWIG_Python_GetModule();
2344     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2345     if (descriptor) {
2346       obj = PyCObject_FromVoidPtr(descriptor, NULL);
2347       PyDict_SetItem(cache, key, obj);
2348       Py_DECREF(obj);
2349     }
2350   }
2351   Py_DECREF(key);
2352   return descriptor;
2353 }
2354
2355 /*
2356    For backward compatibility only
2357 */
2358 #define SWIG_POINTER_EXCEPTION  0
2359 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2360 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2361
2362 SWIGRUNTIME int
2363 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2364 {
2365   if (PyErr_Occurred()) {
2366     PyObject *type = 0;
2367     PyObject *value = 0;
2368     PyObject *traceback = 0;
2369     PyErr_Fetch(&type, &value, &traceback);
2370     if (value) {
2371       PyObject *old_str = PyObject_Str(value);
2372       Py_XINCREF(type);
2373       PyErr_Clear();
2374       if (infront) {
2375         PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2376       } else {
2377         PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2378       }
2379       Py_DECREF(old_str);
2380     }
2381     return 1;
2382   } else {
2383     return 0;
2384   }
2385 }
2386
2387 SWIGRUNTIME int
2388 SWIG_Python_ArgFail(int argnum)
2389 {
2390   if (PyErr_Occurred()) {
2391     /* add information about failing argument */
2392     char mesg[256];
2393     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2394     return SWIG_Python_AddErrMesg(mesg, 1);
2395   } else {
2396     return 0;
2397   }
2398 }
2399
2400 SWIGRUNTIMEINLINE const char *
2401 PySwigObject_GetDesc(PyObject *self)
2402 {
2403   PySwigObject *v = (PySwigObject *)self;
2404   swig_type_info *ty = v ? v->ty : 0;
2405   return ty ? ty->str : (char*)"";
2406 }
2407
2408 SWIGRUNTIME void
2409 SWIG_Python_TypeError(const char *type, PyObject *obj)
2410 {
2411   if (type) {
2412 #if defined(SWIG_COBJECT_TYPES)
2413     if (obj && PySwigObject_Check(obj)) {
2414       const char *otype = (const char *) PySwigObject_GetDesc(obj);
2415       if (otype) {
2416         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2417                      type, otype);
2418         return;
2419       }
2420     } else
2421 #endif
2422     {
2423       const char *otype = (obj ? obj->ob_type->tp_name : 0);
2424       if (otype) {
2425         PyObject *str = PyObject_Str(obj);
2426         const char *cstr = str ? PyString_AsString(str) : 0;
2427         if (cstr) {
2428           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2429                        type, otype, cstr);
2430         } else {
2431           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2432                        type, otype);
2433         }
2434         Py_XDECREF(str);
2435         return;
2436       }
2437     }
2438     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2439   } else {
2440     PyErr_Format(PyExc_TypeError, "unexpected type is received");
2441   }
2442 }
2443
2444
2445 /* Convert a pointer value, signal an exception on a type mismatch */
2446 SWIGRUNTIME void *
2447 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2448   void *result;
2449   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2450     PyErr_Clear();
2451     if (flags & SWIG_POINTER_EXCEPTION) {
2452       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2453       SWIG_Python_ArgFail(argnum);
2454     }
2455   }
2456   return result;
2457 }
2458
2459
2460 #ifdef __cplusplus
2461 #if 0
2462 { /* cc-mode */
2463 #endif
2464 }
2465 #endif
2466
2467
2468
2469 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2470
2471 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2472
2473
2474
2475 /* -------- TYPES TABLE (BEGIN) -------- */
2476
2477 #define SWIGTYPE_p_TALLOC_CTX swig_types[0]
2478 #define SWIGTYPE_p_char swig_types[1]
2479 #define SWIGTYPE_p_int swig_types[2]
2480 #define SWIGTYPE_p_loadparm_context swig_types[3]
2481 #define SWIGTYPE_p_loadparm_service swig_types[4]
2482 #define SWIGTYPE_p_long_long swig_types[5]
2483 #define SWIGTYPE_p_param_context swig_types[6]
2484 #define SWIGTYPE_p_param_opt swig_types[7]
2485 #define SWIGTYPE_p_param_section swig_types[8]
2486 #define SWIGTYPE_p_short swig_types[9]
2487 #define SWIGTYPE_p_signed_char swig_types[10]
2488 #define SWIGTYPE_p_unsigned_char swig_types[11]
2489 #define SWIGTYPE_p_unsigned_int swig_types[12]
2490 #define SWIGTYPE_p_unsigned_long_long swig_types[13]
2491 #define SWIGTYPE_p_unsigned_short swig_types[14]
2492 static swig_type_info *swig_types[16];
2493 static swig_module_info swig_module = {swig_types, 15, 0, 0, 0, 0};
2494 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2495 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2496
2497 /* -------- TYPES TABLE (END) -------- */
2498
2499 #if (PY_VERSION_HEX <= 0x02000000)
2500 # if !defined(SWIG_PYTHON_CLASSIC)
2501 #  error "This python version requires swig to be run with the '-classic' option"
2502 # endif
2503 #endif
2504 #if (PY_VERSION_HEX <= 0x02020000)
2505 # error "This python version requires swig to be run with the '-nomodern' option"
2506 #endif
2507 #if (PY_VERSION_HEX <= 0x02020000)
2508 # error "This python version requires swig to be run with the '-nomodernargs' option"
2509 #endif
2510 #ifndef METH_O
2511 # error "This python version requires swig to be run with the '-nofastunpack' option"
2512 #endif
2513 #ifdef SWIG_TypeQuery
2514 # undef SWIG_TypeQuery
2515 #endif
2516 #define SWIG_TypeQuery SWIG_Python_TypeQuery
2517
2518 /*-----------------------------------------------
2519               @(target):= _param.so
2520   ------------------------------------------------*/
2521 #define SWIG_init    init_param
2522
2523 #define SWIG_name    "_param"
2524
2525 #define SWIGVERSION 0x010335
2526 #define SWIG_VERSION SWIGVERSION
2527
2528
2529 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2530 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2531
2532
2533 #include <stdint.h>
2534 #include <stdbool.h>
2535
2536 #include "includes.h"
2537 #include "param/param.h"
2538 #include "param/loadparm.h"
2539
2540 typedef struct param_context param;
2541 typedef struct loadparm_context loadparm_context;
2542 typedef struct loadparm_service loadparm_service;
2543 typedef struct param_section param_section;
2544 typedef struct param_opt param_opt;
2545
2546 SWIGINTERN loadparm_context *new_loadparm_context(TALLOC_CTX *mem_ctx){ return loadparm_init(mem_ctx); }
2547 SWIGINTERN struct loadparm_service *loadparm_context_default_service(loadparm_context *self){ return lp_default_service(self); }
2548
2549 SWIGINTERN swig_type_info*
2550 SWIG_pchar_descriptor(void)
2551 {
2552   static int init = 0;
2553   static swig_type_info* info = 0;
2554   if (!init) {
2555     info = SWIG_TypeQuery("_p_char");
2556     init = 1;
2557   }
2558   return info;
2559 }
2560
2561
2562 SWIGINTERN int
2563 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2564 {
2565   if (PyString_Check(obj)) {
2566     char *cstr; Py_ssize_t len;
2567     PyString_AsStringAndSize(obj, &cstr, &len);
2568     if (cptr)  {
2569       if (alloc) {
2570         /*
2571            In python the user should not be able to modify the inner
2572            string representation. To warranty that, if you define
2573            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
2574            buffer is always returned.
2575
2576            The default behavior is just to return the pointer value,
2577            so, be careful.
2578         */
2579 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
2580         if (*alloc != SWIG_OLDOBJ)
2581 #else
2582         if (*alloc == SWIG_NEWOBJ)
2583 #endif
2584           {
2585             *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
2586             *alloc = SWIG_NEWOBJ;
2587           }
2588         else {
2589           *cptr = cstr;
2590           *alloc = SWIG_OLDOBJ;
2591         }
2592       } else {
2593         *cptr = PyString_AsString(obj);
2594       }
2595     }
2596     if (psize) *psize = len + 1;
2597     return SWIG_OK;
2598   } else {
2599     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2600     if (pchar_descriptor) {
2601       void* vptr = 0;
2602       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
2603         if (cptr) *cptr = (char *) vptr;
2604         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
2605         if (alloc) *alloc = SWIG_OLDOBJ;
2606         return SWIG_OK;
2607       }
2608     }
2609   }
2610   return SWIG_TypeError;
2611 }
2612
2613
2614
2615
2616 SWIGINTERN bool loadparm_context_load(loadparm_context *self,char const *filename){ return lp_load(self, filename); }
2617
2618 SWIGINTERNINLINE PyObject*
2619   SWIG_From_bool  (bool value)
2620 {
2621   return PyBool_FromLong(value ? 1 : 0);
2622 }
2623
2624 SWIGINTERN bool loadparm_context_load_default(loadparm_context *self){ return lp_load_default(self); }
2625 SWIGINTERN int loadparm_context___len__(loadparm_context *self){ return lp_numservices(self); }
2626
2627   #define SWIG_From_long   PyInt_FromLong
2628
2629
2630 SWIGINTERNINLINE PyObject *
2631 SWIG_From_int  (int value)
2632 {
2633   return SWIG_From_long  (value);
2634 }
2635
2636 SWIGINTERN struct loadparm_service *loadparm_context___getitem__(loadparm_context *self,char const *name){ return lp_service(self, name); }
2637 SWIGINTERN char const *loadparm_context_configfile(loadparm_context *self){ return lp_configfile(self); }
2638
2639 SWIGINTERNINLINE PyObject *
2640 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2641 {
2642   if (carray) {
2643     if (size > INT_MAX) {
2644       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2645       return pchar_descriptor ?
2646         SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2647     } else {
2648       return PyString_FromStringAndSize(carray, (int)(size));
2649     }
2650   } else {
2651     return SWIG_Py_Void();
2652   }
2653 }
2654
2655
2656 SWIGINTERNINLINE PyObject *
2657 SWIG_FromCharPtr(const char *cptr)
2658 {
2659   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2660 }
2661
2662 SWIGINTERN bool loadparm_context_is_mydomain(loadparm_context *self,char const *domain){ return lp_is_mydomain(self, domain); }
2663 SWIGINTERN bool loadparm_context_is_myname(loadparm_context *self,char const *name){ return lp_is_myname(self, name); }
2664 SWIGINTERN int loadparm_context_use(loadparm_context *self,struct param_context *param_ctx){ return param_use(self, param_ctx); }
2665 SWIGINTERN bool loadparm_context_set(loadparm_context *self,char const *parm_name,char const *parm_value){
2666             if (parm_value == NULL)
2667                 return false;
2668             return lp_set_cmdline(self, parm_name, parm_value);
2669         }
2670 SWIGINTERN PyObject *loadparm_context_get(loadparm_context *self,char const *param_name,char const *service_name){
2671             struct parm_struct *parm = NULL;
2672             void *parm_ptr = NULL;
2673             int i;
2674
2675             if (service_name != NULL) {
2676                 struct loadparm_service *service;
2677                 /* its a share parameter */
2678                 service = lp_service(self, service_name);
2679                 if (service == NULL) {
2680                     return Py_None;
2681                 }
2682                 if (strchr(param_name, ':')) {
2683                     /* its a parametric option on a share */
2684                     const char *type = talloc_strndup(self,
2685                                       param_name,
2686                                       strcspn(param_name, ":"));
2687                     const char *option = strchr(param_name, ':') + 1;
2688                     const char *value;
2689                     if (type == NULL || option == NULL) {
2690                         return Py_None;
2691                     }
2692                     value = lp_get_parametric(self, service, type, option);
2693                     if (value == NULL) {
2694                         return Py_None;
2695                     }
2696                     return PyString_FromString(value);
2697                 }
2698
2699                 parm = lp_parm_struct(param_name);
2700                 if (parm == NULL || parm->class == P_GLOBAL) {
2701                     return Py_None;
2702                 }
2703                 parm_ptr = lp_parm_ptr(self, service, parm);
2704             } else if (strchr(param_name, ':')) {
2705                 /* its a global parametric option */
2706                 const char *type = talloc_strndup(self,
2707                                   param_name, strcspn(param_name, ":"));
2708                 const char *option = strchr(param_name, ':') + 1;
2709                 const char *value;
2710                 if (type == NULL || option == NULL) {
2711                     return Py_None;
2712                 }
2713                 value = lp_get_parametric(self, NULL, type, option);
2714                 if (value == NULL)
2715                     return Py_None;
2716                 return PyString_FromString(value);
2717             } else {
2718                 /* its a global parameter */
2719                 parm = lp_parm_struct(param_name);
2720                 if (parm == NULL) {
2721                     return Py_None;
2722                 }
2723                 parm_ptr = lp_parm_ptr(self, NULL, parm);
2724             }
2725
2726             if (parm == NULL || parm_ptr == NULL) {
2727                 return Py_None;
2728             }
2729
2730             /* construct and return the right type of python object */
2731             switch (parm->type) {
2732             case P_STRING:
2733             case P_USTRING:
2734                 return PyString_FromString(*(char **)parm_ptr);
2735             case P_BOOL:
2736                 return PyBool_FromLong(*(bool *)parm_ptr);
2737             case P_INTEGER:
2738             case P_OCTAL:
2739             case P_BYTES:
2740                 return PyLong_FromLong(*(int *)parm_ptr);
2741             case P_ENUM:
2742                 for (i=0; parm->enum_list[i].name; i++) {
2743                     if (*(int *)parm_ptr == parm->enum_list[i].value) {
2744                         return PyString_FromString(parm->enum_list[i].name);
2745                     }
2746                 }
2747                 return Py_None;
2748             case P_LIST:
2749                 {
2750                     int j;
2751                     const char **strlist = *(const char ***)parm_ptr;
2752                     PyObject *pylist = PyList_New(str_list_length(strlist));
2753                     for (j = 0; strlist[j]; j++)
2754                         PyList_SetItem(pylist, j,
2755                                        PyString_FromString(strlist[j]));
2756                     return pylist;
2757                 }
2758
2759                 break;
2760             }
2761             return Py_None;
2762         }
2763 SWIGINTERN void delete_loadparm_context(loadparm_context *self){ talloc_free(self); }
2764 SWIGINTERN char const *loadparm_service_volume_label(loadparm_service *self,struct loadparm_service *sDefault){ return volume_label(self, sDefault); }
2765 SWIGINTERN char const *loadparm_service_printername(loadparm_service *self,struct loadparm_service *sDefault){ return lp_printername(self, sDefault); }
2766 SWIGINTERN int loadparm_service_maxprintjobs(loadparm_service *self,struct loadparm_service *sDefault){ return lp_maxprintjobs(self, sDefault); }
2767 SWIGINTERN param *new_param(TALLOC_CTX *mem_ctx){ return param_init(mem_ctx); }
2768 SWIGINTERN int param_set(param *self,char const *parameter,PyObject *ob,char const *section_name){
2769             struct param_opt *opt = param_get_add(self, parameter, section_name);
2770
2771             talloc_free(opt->value);
2772             opt->value = talloc_strdup(opt, PyString_AsString(PyObject_Str(ob)));
2773
2774             return 0;
2775         }
2776 SWIGINTERN struct param_section *param_first_section(param *self){ return self->sections; }
2777 SWIGINTERN struct param_section *param_next_section(param *self,struct param_section *s){ return s->next; }
2778 SWIGINTERN void delete_param(param *self){ talloc_free(self); }
2779 SWIGINTERN char const *param_opt___str__(param_opt *self){ return self->value; }
2780 SWIGINTERN void delete_param_opt(param_opt *self){ talloc_free(self); }
2781 SWIGINTERN struct param_opt *param_section_first_parameter(param_section *self){ return self->parameters; }
2782 SWIGINTERN struct param_opt *param_section_next_parameter(param_section *self,struct param_opt *s){ return s->next; }
2783
2784
2785 struct loadparm_context *lp_from_py_object(PyObject *py_obj)
2786 {
2787     struct loadparm_context *lp_ctx;
2788     if (PyString_Check(py_obj)) {
2789         lp_ctx = loadparm_init(NULL);
2790         if (!lp_load(lp_ctx, PyString_AsString(py_obj))) {
2791             talloc_free(lp_ctx);
2792             return NULL;
2793         }
2794         return lp_ctx;
2795     }
2796
2797     if (py_obj == Py_None) {
2798         lp_ctx = loadparm_init(NULL);
2799         if (!lp_load_default(lp_ctx)) {
2800             talloc_free(lp_ctx);
2801             return NULL;
2802         }
2803         return lp_ctx;
2804     }
2805
2806     if (SWIG_ConvertPtr(py_obj, (void *)&lp_ctx, SWIGTYPE_p_loadparm_context, 0 |  0 ) < 0)
2807         return NULL;
2808     return lp_ctx;
2809 }
2810
2811
2812 #ifdef __cplusplus
2813 extern "C" {
2814 #endif
2815 SWIGINTERN PyObject *_wrap_new_LoadParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2816   PyObject *resultobj = 0;
2817   TALLOC_CTX *arg1 = (TALLOC_CTX *) 0 ;
2818   loadparm_context *result = 0 ;
2819
2820   arg1 = NULL;
2821   if (!SWIG_Python_UnpackTuple(args,"new_LoadParm",0,0,0)) SWIG_fail;
2822   result = (loadparm_context *)new_loadparm_context(arg1);
2823   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_loadparm_context, SWIG_POINTER_NEW |  0 );
2824   return resultobj;
2825 fail:
2826   return NULL;
2827 }
2828
2829
2830 SWIGINTERN PyObject *_wrap_LoadParm_default_service(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
2831   PyObject *resultobj = 0;
2832   loadparm_context *arg1 = (loadparm_context *) 0 ;
2833   struct loadparm_service *result = 0 ;
2834   void *argp1 = 0 ;
2835   int res1 = 0 ;
2836   PyObject * obj0 = 0 ;
2837   char *  kwnames[] = {
2838     (char *) "self", NULL
2839   };
2840
2841   arg1 = loadparm_init(NULL);
2842   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:LoadParm_default_service",kwnames,&obj0)) SWIG_fail;
2843   if (obj0) {
2844     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 |  0 );
2845     if (!SWIG_IsOK(res1)) {
2846       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm_default_service" "', argument " "1"" of type '" "loadparm_context *""'");
2847     }
2848     arg1 = (loadparm_context *)(argp1);
2849   }
2850   result = (struct loadparm_service *)loadparm_context_default_service(arg1);
2851   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_loadparm_service, 0 |  0 );
2852   return resultobj;
2853 fail:
2854   return NULL;
2855 }
2856
2857
2858 SWIGINTERN PyObject *_wrap_LoadParm_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
2859   PyObject *resultobj = 0;
2860   loadparm_context *arg1 = (loadparm_context *) 0 ;
2861   char *arg2 = (char *) 0 ;
2862   bool result;
2863   void *argp1 = 0 ;
2864   int res1 = 0 ;
2865   int res2 ;
2866   char *buf2 = 0 ;
2867   int alloc2 = 0 ;
2868   PyObject * obj0 = 0 ;
2869   PyObject * obj1 = 0 ;
2870   char *  kwnames[] = {
2871     (char *) "self",(char *) "filename", NULL
2872   };
2873
2874   arg1 = loadparm_init(NULL);
2875   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:LoadParm_load",kwnames,&obj0,&obj1)) SWIG_fail;
2876   if (obj0) {
2877     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 |  0 );
2878     if (!SWIG_IsOK(res1)) {
2879       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm_load" "', argument " "1"" of type '" "loadparm_context *""'");
2880     }
2881     arg1 = (loadparm_context *)(argp1);
2882   }
2883   if (obj1) {
2884     res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
2885     if (!SWIG_IsOK(res2)) {
2886       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoadParm_load" "', argument " "2"" of type '" "char const *""'");
2887     }
2888     arg2 = (char *)(buf2);
2889   }
2890   result = (bool)loadparm_context_load(arg1,(char const *)arg2);
2891   resultobj = SWIG_From_bool((bool)(result));
2892   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2893   return resultobj;
2894 fail:
2895   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2896   return NULL;
2897 }
2898
2899
2900 SWIGINTERN PyObject *_wrap_LoadParm_load_default(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
2901   PyObject *resultobj = 0;
2902   loadparm_context *arg1 = (loadparm_context *) 0 ;
2903   bool result;
2904   void *argp1 = 0 ;
2905   int res1 = 0 ;
2906   PyObject * obj0 = 0 ;
2907   char *  kwnames[] = {
2908     (char *) "self", NULL
2909   };
2910
2911   arg1 = loadparm_init(NULL);
2912   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:LoadParm_load_default",kwnames,&obj0)) SWIG_fail;
2913   if (obj0) {
2914     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 |  0 );
2915     if (!SWIG_IsOK(res1)) {
2916       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm_load_default" "', argument " "1"" of type '" "loadparm_context *""'");
2917     }
2918     arg1 = (loadparm_context *)(argp1);
2919   }
2920   result = (bool)loadparm_context_load_default(arg1);
2921   resultobj = SWIG_From_bool((bool)(result));
2922   return resultobj;
2923 fail:
2924   return NULL;
2925 }
2926
2927
2928 SWIGINTERN PyObject *_wrap_LoadParm___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
2929   PyObject *resultobj = 0;
2930   loadparm_context *arg1 = (loadparm_context *) 0 ;
2931   int result;
2932   void *argp1 = 0 ;
2933   int res1 = 0 ;
2934   PyObject * obj0 = 0 ;
2935   char *  kwnames[] = {
2936     (char *) "self", NULL
2937   };
2938
2939   arg1 = loadparm_init(NULL);
2940   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:LoadParm___len__",kwnames,&obj0)) SWIG_fail;
2941   if (obj0) {
2942     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 |  0 );
2943     if (!SWIG_IsOK(res1)) {
2944       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm___len__" "', argument " "1"" of type '" "loadparm_context *""'");
2945     }
2946     arg1 = (loadparm_context *)(argp1);
2947   }
2948   result = (int)loadparm_context___len__(arg1);
2949   resultobj = SWIG_From_int((int)(result));
2950   return resultobj;
2951 fail:
2952   return NULL;
2953 }
2954
2955
2956 SWIGINTERN PyObject *_wrap_LoadParm___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
2957   PyObject *resultobj = 0;
2958   loadparm_context *arg1 = (loadparm_context *) 0 ;
2959   char *arg2 = (char *) 0 ;
2960   struct loadparm_service *result = 0 ;
2961   void *argp1 = 0 ;
2962   int res1 = 0 ;
2963   int res2 ;
2964   char *buf2 = 0 ;
2965   int alloc2 = 0 ;
2966   PyObject * obj0 = 0 ;
2967   PyObject * obj1 = 0 ;
2968   char *  kwnames[] = {
2969     (char *) "self",(char *) "name", NULL
2970   };
2971
2972   arg1 = loadparm_init(NULL);
2973   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:LoadParm___getitem__",kwnames,&obj0,&obj1)) SWIG_fail;
2974   if (obj0) {
2975     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 |  0 );
2976     if (!SWIG_IsOK(res1)) {
2977       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm___getitem__" "', argument " "1"" of type '" "loadparm_context *""'");
2978     }
2979     arg1 = (loadparm_context *)(argp1);
2980   }
2981   if (obj1) {
2982     res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
2983     if (!SWIG_IsOK(res2)) {
2984       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoadParm___getitem__" "', argument " "2"" of type '" "char const *""'");
2985     }
2986     arg2 = (char *)(buf2);
2987   }
2988   result = (struct loadparm_service *)loadparm_context___getitem__(arg1,(char const *)arg2);
2989   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_loadparm_service, 0 |  0 );
2990   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2991   return resultobj;
2992 fail:
2993   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2994   return NULL;
2995 }
2996
2997
2998 SWIGINTERN PyObject *_wrap_LoadParm_configfile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
2999   PyObject *resultobj = 0;
3000   loadparm_context *arg1 = (loadparm_context *) 0 ;
3001   char *result = 0 ;
3002   void *argp1 = 0 ;
3003   int res1 = 0 ;
3004   PyObject * obj0 = 0 ;
3005   char *  kwnames[] = {
3006     (char *) "self", NULL
3007   };
3008
3009   arg1 = loadparm_init(NULL);
3010   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:LoadParm_configfile",kwnames,&obj0)) SWIG_fail;
3011   if (obj0) {
3012     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 |  0 );
3013     if (!SWIG_IsOK(res1)) {
3014       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm_configfile" "', argument " "1"" of type '" "loadparm_context *""'");
3015     }
3016     arg1 = (loadparm_context *)(argp1);
3017   }
3018   result = (char *)loadparm_context_configfile(arg1);
3019   resultobj = SWIG_FromCharPtr((const char *)result);
3020   return resultobj;
3021 fail:
3022   return NULL;
3023 }
3024
3025
3026 SWIGINTERN PyObject *_wrap_LoadParm_is_mydomain(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3027   PyObject *resultobj = 0;
3028   loadparm_context *arg1 = (loadparm_context *) 0 ;
3029   char *arg2 = (char *) 0 ;
3030   bool result;
3031   void *argp1 = 0 ;
3032   int res1 = 0 ;
3033   int res2 ;
3034   char *buf2 = 0 ;
3035   int alloc2 = 0 ;
3036   PyObject * obj0 = 0 ;
3037   PyObject * obj1 = 0 ;
3038   char *  kwnames[] = {
3039     (char *) "self",(char *) "domain", NULL
3040   };
3041
3042   arg1 = loadparm_init(NULL);
3043   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:LoadParm_is_mydomain",kwnames,&obj0,&obj1)) SWIG_fail;
3044   if (obj0) {
3045     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 |  0 );
3046     if (!SWIG_IsOK(res1)) {
3047       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm_is_mydomain" "', argument " "1"" of type '" "loadparm_context *""'");
3048     }
3049     arg1 = (loadparm_context *)(argp1);
3050   }
3051   if (obj1) {
3052     res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3053     if (!SWIG_IsOK(res2)) {
3054       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoadParm_is_mydomain" "', argument " "2"" of type '" "char const *""'");
3055     }
3056     arg2 = (char *)(buf2);
3057   }
3058   result = (bool)loadparm_context_is_mydomain(arg1,(char const *)arg2);
3059   resultobj = SWIG_From_bool((bool)(result));
3060   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3061   return resultobj;
3062 fail:
3063   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3064   return NULL;
3065 }
3066
3067
3068 SWIGINTERN PyObject *_wrap_LoadParm_is_myname(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3069   PyObject *resultobj = 0;
3070   loadparm_context *arg1 = (loadparm_context *) 0 ;
3071   char *arg2 = (char *) 0 ;
3072   bool result;
3073   void *argp1 = 0 ;
3074   int res1 = 0 ;
3075   int res2 ;
3076   char *buf2 = 0 ;
3077   int alloc2 = 0 ;
3078   PyObject * obj0 = 0 ;
3079   PyObject * obj1 = 0 ;
3080   char *  kwnames[] = {
3081     (char *) "self",(char *) "name", NULL
3082   };
3083
3084   arg1 = loadparm_init(NULL);
3085   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:LoadParm_is_myname",kwnames,&obj0,&obj1)) SWIG_fail;
3086   if (obj0) {
3087     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 |  0 );
3088     if (!SWIG_IsOK(res1)) {
3089       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm_is_myname" "', argument " "1"" of type '" "loadparm_context *""'");
3090     }
3091     arg1 = (loadparm_context *)(argp1);
3092   }
3093   if (obj1) {
3094     res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3095     if (!SWIG_IsOK(res2)) {
3096       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoadParm_is_myname" "', argument " "2"" of type '" "char const *""'");
3097     }
3098     arg2 = (char *)(buf2);
3099   }
3100   result = (bool)loadparm_context_is_myname(arg1,(char const *)arg2);
3101   resultobj = SWIG_From_bool((bool)(result));
3102   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3103   return resultobj;
3104 fail:
3105   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3106   return NULL;
3107 }
3108
3109
3110 SWIGINTERN PyObject *_wrap_LoadParm_use(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3111   PyObject *resultobj = 0;
3112   loadparm_context *arg1 = (loadparm_context *) 0 ;
3113   struct param_context *arg2 = (struct param_context *) 0 ;
3114   int result;
3115   void *argp1 = 0 ;
3116   int res1 = 0 ;
3117   void *argp2 = 0 ;
3118   int res2 = 0 ;
3119   PyObject * obj0 = 0 ;
3120   PyObject * obj1 = 0 ;
3121   char *  kwnames[] = {
3122     (char *) "self",(char *) "param_ctx", NULL
3123   };
3124
3125   arg1 = loadparm_init(NULL);
3126   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:LoadParm_use",kwnames,&obj0,&obj1)) SWIG_fail;
3127   if (obj0) {
3128     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 |  0 );
3129     if (!SWIG_IsOK(res1)) {
3130       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm_use" "', argument " "1"" of type '" "loadparm_context *""'");
3131     }
3132     arg1 = (loadparm_context *)(argp1);
3133   }
3134   if (obj1) {
3135     res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_param_context, 0 |  0 );
3136     if (!SWIG_IsOK(res2)) {
3137       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoadParm_use" "', argument " "2"" of type '" "struct param_context *""'");
3138     }
3139     arg2 = (struct param_context *)(argp2);
3140   }
3141   result = (int)loadparm_context_use(arg1,arg2);
3142   resultobj = SWIG_From_int((int)(result));
3143   return resultobj;
3144 fail:
3145   return NULL;
3146 }
3147
3148
3149 SWIGINTERN PyObject *_wrap_LoadParm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3150   PyObject *resultobj = 0;
3151   loadparm_context *arg1 = (loadparm_context *) 0 ;
3152   char *arg2 = (char *) 0 ;
3153   char *arg3 = (char *) 0 ;
3154   bool result;
3155   void *argp1 = 0 ;
3156   int res1 = 0 ;
3157   int res2 ;
3158   char *buf2 = 0 ;
3159   int alloc2 = 0 ;
3160   int res3 ;
3161   char *buf3 = 0 ;
3162   int alloc3 = 0 ;
3163   PyObject * obj0 = 0 ;
3164   PyObject * obj1 = 0 ;
3165   PyObject * obj2 = 0 ;
3166   char *  kwnames[] = {
3167     (char *) "self",(char *) "parm_name",(char *) "parm_value", NULL
3168   };
3169
3170   arg1 = loadparm_init(NULL);
3171   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:LoadParm_set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3172   if (obj0) {
3173     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 |  0 );
3174     if (!SWIG_IsOK(res1)) {
3175       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm_set" "', argument " "1"" of type '" "loadparm_context *""'");
3176     }
3177     arg1 = (loadparm_context *)(argp1);
3178   }
3179   if (obj1) {
3180     res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3181     if (!SWIG_IsOK(res2)) {
3182       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoadParm_set" "', argument " "2"" of type '" "char const *""'");
3183     }
3184     arg2 = (char *)(buf2);
3185   }
3186   if (obj2) {
3187     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3188     if (!SWIG_IsOK(res3)) {
3189       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoadParm_set" "', argument " "3"" of type '" "char const *""'");
3190     }
3191     arg3 = (char *)(buf3);
3192   }
3193   result = (bool)loadparm_context_set(arg1,(char const *)arg2,(char const *)arg3);
3194   resultobj = SWIG_From_bool((bool)(result));
3195   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3196   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3197   return resultobj;
3198 fail:
3199   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3200   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3201   return NULL;
3202 }
3203
3204
3205 SWIGINTERN PyObject *_wrap_LoadParm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3206   PyObject *resultobj = 0;
3207   loadparm_context *arg1 = (loadparm_context *) 0 ;
3208   char *arg2 = (char *) 0 ;
3209   char *arg3 = (char *) 0 ;
3210   PyObject *result = 0 ;
3211   void *argp1 = 0 ;
3212   int res1 = 0 ;
3213   int res2 ;
3214   char *buf2 = 0 ;
3215   int alloc2 = 0 ;
3216   int res3 ;
3217   char *buf3 = 0 ;
3218   int alloc3 = 0 ;
3219   PyObject * obj0 = 0 ;
3220   PyObject * obj1 = 0 ;
3221   PyObject * obj2 = 0 ;
3222   char *  kwnames[] = {
3223     (char *) "self",(char *) "param_name",(char *) "service_name", NULL
3224   };
3225
3226   arg1 = loadparm_init(NULL);
3227   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:LoadParm_get",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3228   if (obj0) {
3229     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, 0 |  0 );
3230     if (!SWIG_IsOK(res1)) {
3231       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LoadParm_get" "', argument " "1"" of type '" "loadparm_context *""'");
3232     }
3233     arg1 = (loadparm_context *)(argp1);
3234   }
3235   if (obj1) {
3236     res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3237     if (!SWIG_IsOK(res2)) {
3238       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LoadParm_get" "', argument " "2"" of type '" "char const *""'");
3239     }
3240     arg2 = (char *)(buf2);
3241   }
3242   if (obj2) {
3243     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3244     if (!SWIG_IsOK(res3)) {
3245       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LoadParm_get" "', argument " "3"" of type '" "char const *""'");
3246     }
3247     arg3 = (char *)(buf3);
3248   }
3249   result = (PyObject *)loadparm_context_get(arg1,(char const *)arg2,(char const *)arg3);
3250   resultobj = result;
3251   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3252   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3253   return resultobj;
3254 fail:
3255   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3256   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3257   return NULL;
3258 }
3259
3260
3261 SWIGINTERN PyObject *_wrap_delete_LoadParm(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3262   PyObject *resultobj = 0;
3263   loadparm_context *arg1 = (loadparm_context *) 0 ;
3264   void *argp1 = 0 ;
3265   int res1 = 0 ;
3266   PyObject * obj0 = 0 ;
3267   char *  kwnames[] = {
3268     (char *) "self", NULL
3269   };
3270
3271   arg1 = loadparm_init(NULL);
3272   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:delete_LoadParm",kwnames,&obj0)) SWIG_fail;
3273   if (obj0) {
3274     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_context, SWIG_POINTER_DISOWN |  0 );
3275     if (!SWIG_IsOK(res1)) {
3276       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LoadParm" "', argument " "1"" of type '" "loadparm_context *""'");
3277     }
3278     arg1 = (loadparm_context *)(argp1);
3279   }
3280   delete_loadparm_context(arg1);
3281
3282   resultobj = SWIG_Py_Void();
3283   return resultobj;
3284 fail:
3285   return NULL;
3286 }
3287
3288
3289 SWIGINTERN PyObject *LoadParm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3290   PyObject *obj;
3291   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3292   SWIG_TypeNewClientData(SWIGTYPE_p_loadparm_context, SWIG_NewClientData(obj));
3293   return SWIG_Py_Void();
3294 }
3295
3296 SWIGINTERN PyObject *LoadParm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3297   return SWIG_Python_InitShadowInstance(args);
3298 }
3299
3300 SWIGINTERN PyObject *_wrap_loadparm_service_volume_label(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3301   PyObject *resultobj = 0;
3302   loadparm_service *arg1 = (loadparm_service *) 0 ;
3303   struct loadparm_service *arg2 = (struct loadparm_service *) 0 ;
3304   char *result = 0 ;
3305   void *argp1 = 0 ;
3306   int res1 = 0 ;
3307   void *argp2 = 0 ;
3308   int res2 = 0 ;
3309   PyObject * obj0 = 0 ;
3310   PyObject * obj1 = 0 ;
3311   char *  kwnames[] = {
3312     (char *) "self",(char *) "sDefault", NULL
3313   };
3314
3315   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:loadparm_service_volume_label",kwnames,&obj0,&obj1)) SWIG_fail;
3316   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_service, 0 |  0 );
3317   if (!SWIG_IsOK(res1)) {
3318     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loadparm_service_volume_label" "', argument " "1"" of type '" "loadparm_service *""'");
3319   }
3320   arg1 = (loadparm_service *)(argp1);
3321   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_loadparm_service, 0 |  0 );
3322   if (!SWIG_IsOK(res2)) {
3323     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "loadparm_service_volume_label" "', argument " "2"" of type '" "struct loadparm_service *""'");
3324   }
3325   arg2 = (struct loadparm_service *)(argp2);
3326   result = (char *)loadparm_service_volume_label(arg1,arg2);
3327   resultobj = SWIG_FromCharPtr((const char *)result);
3328   return resultobj;
3329 fail:
3330   return NULL;
3331 }
3332
3333
3334 SWIGINTERN PyObject *_wrap_loadparm_service_printername(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3335   PyObject *resultobj = 0;
3336   loadparm_service *arg1 = (loadparm_service *) 0 ;
3337   struct loadparm_service *arg2 = (struct loadparm_service *) 0 ;
3338   char *result = 0 ;
3339   void *argp1 = 0 ;
3340   int res1 = 0 ;
3341   void *argp2 = 0 ;
3342   int res2 = 0 ;
3343   PyObject * obj0 = 0 ;
3344   PyObject * obj1 = 0 ;
3345   char *  kwnames[] = {
3346     (char *) "self",(char *) "sDefault", NULL
3347   };
3348
3349   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:loadparm_service_printername",kwnames,&obj0,&obj1)) SWIG_fail;
3350   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_service, 0 |  0 );
3351   if (!SWIG_IsOK(res1)) {
3352     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loadparm_service_printername" "', argument " "1"" of type '" "loadparm_service *""'");
3353   }
3354   arg1 = (loadparm_service *)(argp1);
3355   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_loadparm_service, 0 |  0 );
3356   if (!SWIG_IsOK(res2)) {
3357     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "loadparm_service_printername" "', argument " "2"" of type '" "struct loadparm_service *""'");
3358   }
3359   arg2 = (struct loadparm_service *)(argp2);
3360   result = (char *)loadparm_service_printername(arg1,arg2);
3361   resultobj = SWIG_FromCharPtr((const char *)result);
3362   return resultobj;
3363 fail:
3364   return NULL;
3365 }
3366
3367
3368 SWIGINTERN PyObject *_wrap_loadparm_service_maxprintjobs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3369   PyObject *resultobj = 0;
3370   loadparm_service *arg1 = (loadparm_service *) 0 ;
3371   struct loadparm_service *arg2 = (struct loadparm_service *) 0 ;
3372   int result;
3373   void *argp1 = 0 ;
3374   int res1 = 0 ;
3375   void *argp2 = 0 ;
3376   int res2 = 0 ;
3377   PyObject * obj0 = 0 ;
3378   PyObject * obj1 = 0 ;
3379   char *  kwnames[] = {
3380     (char *) "self",(char *) "sDefault", NULL
3381   };
3382
3383   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:loadparm_service_maxprintjobs",kwnames,&obj0,&obj1)) SWIG_fail;
3384   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_loadparm_service, 0 |  0 );
3385   if (!SWIG_IsOK(res1)) {
3386     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loadparm_service_maxprintjobs" "', argument " "1"" of type '" "loadparm_service *""'");
3387   }
3388   arg1 = (loadparm_service *)(argp1);
3389   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_loadparm_service, 0 |  0 );
3390   if (!SWIG_IsOK(res2)) {
3391     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "loadparm_service_maxprintjobs" "', argument " "2"" of type '" "struct loadparm_service *""'");
3392   }
3393   arg2 = (struct loadparm_service *)(argp2);
3394   result = (int)loadparm_service_maxprintjobs(arg1,arg2);
3395   resultobj = SWIG_From_int((int)(result));
3396   return resultobj;
3397 fail:
3398   return NULL;
3399 }
3400
3401
3402 SWIGINTERN PyObject *loadparm_service_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3403   PyObject *obj;
3404   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3405   SWIG_TypeNewClientData(SWIGTYPE_p_loadparm_service, SWIG_NewClientData(obj));
3406   return SWIG_Py_Void();
3407 }
3408
3409 SWIGINTERN PyObject *_wrap_new_ParamFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3410   PyObject *resultobj = 0;
3411   TALLOC_CTX *arg1 = (TALLOC_CTX *) 0 ;
3412   param *result = 0 ;
3413
3414   arg1 = NULL;
3415   if (!SWIG_Python_UnpackTuple(args,"new_ParamFile",0,0,0)) SWIG_fail;
3416   result = (param *)new_param(arg1);
3417   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_param_context, SWIG_POINTER_NEW |  0 );
3418   return resultobj;
3419 fail:
3420   return NULL;
3421 }
3422
3423
3424 SWIGINTERN PyObject *_wrap_ParamFile_get_section(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3425   PyObject *resultobj = 0;
3426   param *arg1 = (param *) 0 ;
3427   char *arg2 = (char *) 0 ;
3428   struct param_section *result = 0 ;
3429   void *argp1 = 0 ;
3430   int res1 = 0 ;
3431   int res2 ;
3432   char *buf2 = 0 ;
3433   int alloc2 = 0 ;
3434   PyObject * obj0 = 0 ;
3435   PyObject * obj1 = 0 ;
3436   char *  kwnames[] = {
3437     (char *) "self",(char *) "name", NULL
3438   };
3439
3440   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ParamFile_get_section",kwnames,&obj0,&obj1)) SWIG_fail;
3441   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 |  0 );
3442   if (!SWIG_IsOK(res1)) {
3443     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamFile_get_section" "', argument " "1"" of type '" "param *""'");
3444   }
3445   arg1 = (param *)(argp1);
3446   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3447   if (!SWIG_IsOK(res2)) {
3448     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParamFile_get_section" "', argument " "2"" of type '" "char const *""'");
3449   }
3450   arg2 = (char *)(buf2);
3451   result = (struct param_section *)param_get_section(arg1,(char const *)arg2);
3452   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_param_section, 0 |  0 );
3453   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3454   return resultobj;
3455 fail:
3456   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3457   return NULL;
3458 }
3459
3460
3461 SWIGINTERN PyObject *_wrap_ParamFile_add_section(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3462   PyObject *resultobj = 0;
3463   param *arg1 = (param *) 0 ;
3464   char *arg2 = (char *) 0 ;
3465   struct param_section *result = 0 ;
3466   void *argp1 = 0 ;
3467   int res1 = 0 ;
3468   int res2 ;
3469   char *buf2 = 0 ;
3470   int alloc2 = 0 ;
3471   PyObject * obj0 = 0 ;
3472   PyObject * obj1 = 0 ;
3473   char *  kwnames[] = {
3474     (char *) "self",(char *) "name", NULL
3475   };
3476
3477   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ParamFile_add_section",kwnames,&obj0,&obj1)) SWIG_fail;
3478   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 |  0 );
3479   if (!SWIG_IsOK(res1)) {
3480     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamFile_add_section" "', argument " "1"" of type '" "param *""'");
3481   }
3482   arg1 = (param *)(argp1);
3483   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3484   if (!SWIG_IsOK(res2)) {
3485     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParamFile_add_section" "', argument " "2"" of type '" "char const *""'");
3486   }
3487   arg2 = (char *)(buf2);
3488   result = (struct param_section *)param_add_section(arg1,(char const *)arg2);
3489   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_param_section, 0 |  0 );
3490   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3491   return resultobj;
3492 fail:
3493   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3494   return NULL;
3495 }
3496
3497
3498 SWIGINTERN PyObject *_wrap_ParamFile_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3499   PyObject *resultobj = 0;
3500   param *arg1 = (param *) 0 ;
3501   char *arg2 = (char *) 0 ;
3502   char *arg3 = (char *) "global" ;
3503   struct param_opt *result = 0 ;
3504   void *argp1 = 0 ;
3505   int res1 = 0 ;
3506   int res2 ;
3507   char *buf2 = 0 ;
3508   int alloc2 = 0 ;
3509   int res3 ;
3510   char *buf3 = 0 ;
3511   int alloc3 = 0 ;
3512   PyObject * obj0 = 0 ;
3513   PyObject * obj1 = 0 ;
3514   PyObject * obj2 = 0 ;
3515   char *  kwnames[] = {
3516     (char *) "self",(char *) "name",(char *) "section_name", NULL
3517   };
3518
3519   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ParamFile_get",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3520   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 |  0 );
3521   if (!SWIG_IsOK(res1)) {
3522     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamFile_get" "', argument " "1"" of type '" "param *""'");
3523   }
3524   arg1 = (param *)(argp1);
3525   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3526   if (!SWIG_IsOK(res2)) {
3527     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParamFile_get" "', argument " "2"" of type '" "char const *""'");
3528   }
3529   arg2 = (char *)(buf2);
3530   if (obj2) {
3531     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3532     if (!SWIG_IsOK(res3)) {
3533       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParamFile_get" "', argument " "3"" of type '" "char const *""'");
3534     }
3535     arg3 = (char *)(buf3);
3536   }
3537   result = (struct param_opt *)param_get(arg1,(char const *)arg2,(char const *)arg3);
3538   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_param_opt, 0 |  0 );
3539   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3540   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3541   return resultobj;
3542 fail:
3543   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3544   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3545   return NULL;
3546 }
3547
3548
3549 SWIGINTERN PyObject *_wrap_ParamFile_get_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3550   PyObject *resultobj = 0;
3551   param *arg1 = (param *) 0 ;
3552   char *arg2 = (char *) 0 ;
3553   char *arg3 = (char *) "global" ;
3554   char *result = 0 ;
3555   void *argp1 = 0 ;
3556   int res1 = 0 ;
3557   int res2 ;
3558   char *buf2 = 0 ;
3559   int alloc2 = 0 ;
3560   int res3 ;
3561   char *buf3 = 0 ;
3562   int alloc3 = 0 ;
3563   PyObject * obj0 = 0 ;
3564   PyObject * obj1 = 0 ;
3565   PyObject * obj2 = 0 ;
3566   char *  kwnames[] = {
3567     (char *) "self",(char *) "name",(char *) "section_name", NULL
3568   };
3569
3570   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ParamFile_get_string",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3571   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 |  0 );
3572   if (!SWIG_IsOK(res1)) {
3573     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamFile_get_string" "', argument " "1"" of type '" "param *""'");
3574   }
3575   arg1 = (param *)(argp1);
3576   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3577   if (!SWIG_IsOK(res2)) {
3578     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParamFile_get_string" "', argument " "2"" of type '" "char const *""'");
3579   }
3580   arg2 = (char *)(buf2);
3581   if (obj2) {
3582     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3583     if (!SWIG_IsOK(res3)) {
3584       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParamFile_get_string" "', argument " "3"" of type '" "char const *""'");
3585     }
3586     arg3 = (char *)(buf3);
3587   }
3588   result = (char *)param_get_string(arg1,(char const *)arg2,(char const *)arg3);
3589   resultobj = SWIG_FromCharPtr((const char *)result);
3590   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3591   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3592   return resultobj;
3593 fail:
3594   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3595   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3596   return NULL;
3597 }
3598
3599
3600 SWIGINTERN PyObject *_wrap_ParamFile_set_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3601   PyObject *resultobj = 0;
3602   param *arg1 = (param *) 0 ;
3603   char *arg2 = (char *) 0 ;
3604   char *arg3 = (char *) 0 ;
3605   char *arg4 = (char *) "global" ;
3606   int result;
3607   void *argp1 = 0 ;
3608   int res1 = 0 ;
3609   int res2 ;
3610   char *buf2 = 0 ;
3611   int alloc2 = 0 ;
3612   int res3 ;
3613   char *buf3 = 0 ;
3614   int alloc3 = 0 ;
3615   int res4 ;
3616   char *buf4 = 0 ;
3617   int alloc4 = 0 ;
3618   PyObject * obj0 = 0 ;
3619   PyObject * obj1 = 0 ;
3620   PyObject * obj2 = 0 ;
3621   PyObject * obj3 = 0 ;
3622   char *  kwnames[] = {
3623     (char *) "self",(char *) "param",(char *) "value",(char *) "section", NULL
3624   };
3625
3626   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ParamFile_set_string",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3627   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 |  0 );
3628   if (!SWIG_IsOK(res1)) {
3629     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamFile_set_string" "', argument " "1"" of type '" "param *""'");
3630   }
3631   arg1 = (param *)(argp1);
3632   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3633   if (!SWIG_IsOK(res2)) {
3634     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParamFile_set_string" "', argument " "2"" of type '" "char const *""'");
3635   }
3636   arg2 = (char *)(buf2);
3637   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3638   if (!SWIG_IsOK(res3)) {
3639     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParamFile_set_string" "', argument " "3"" of type '" "char const *""'");
3640   }
3641   arg3 = (char *)(buf3);
3642   if (obj3) {
3643     res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
3644     if (!SWIG_IsOK(res4)) {
3645       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParamFile_set_string" "', argument " "4"" of type '" "char const *""'");
3646     }
3647     arg4 = (char *)(buf4);
3648   }
3649   result = (int)param_set_string(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
3650   resultobj = SWIG_From_int((int)(result));
3651   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3652   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3653   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3654   return resultobj;
3655 fail:
3656   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3657   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3658   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3659   return NULL;
3660 }
3661
3662
3663 SWIGINTERN PyObject *_wrap_ParamFile_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3664   PyObject *resultobj = 0;
3665   param *arg1 = (param *) 0 ;
3666   char *arg2 = (char *) 0 ;
3667   PyObject *arg3 = (PyObject *) 0 ;
3668   char *arg4 = (char *) "global" ;
3669   int result;
3670   void *argp1 = 0 ;
3671   int res1 = 0 ;
3672   int res2 ;
3673   char *buf2 = 0 ;
3674   int alloc2 = 0 ;
3675   int res4 ;
3676   char *buf4 = 0 ;
3677   int alloc4 = 0 ;
3678   PyObject * obj0 = 0 ;
3679   PyObject * obj1 = 0 ;
3680   PyObject * obj2 = 0 ;
3681   PyObject * obj3 = 0 ;
3682   char *  kwnames[] = {
3683     (char *) "self",(char *) "parameter",(char *) "ob",(char *) "section_name", NULL
3684   };
3685
3686   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ParamFile_set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3687   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 |  0 );
3688   if (!SWIG_IsOK(res1)) {
3689     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamFile_set" "', argument " "1"" of type '" "param *""'");
3690   }
3691   arg1 = (param *)(argp1);
3692   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3693   if (!SWIG_IsOK(res2)) {
3694     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParamFile_set" "', argument " "2"" of type '" "char const *""'");
3695   }
3696   arg2 = (char *)(buf2);
3697   arg3 = obj2;
3698   if (obj3) {
3699     res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
3700     if (!SWIG_IsOK(res4)) {
3701       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParamFile_set" "', argument " "4"" of type '" "char const *""'");
3702     }
3703     arg4 = (char *)(buf4);
3704   }
3705   result = (int)param_set(arg1,(char const *)arg2,arg3,(char const *)arg4);
3706   resultobj = SWIG_From_int((int)(result));
3707   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3708   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3709   return resultobj;
3710 fail:
3711   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3712   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3713   return NULL;
3714 }
3715
3716
3717 SWIGINTERN PyObject *_wrap_ParamFile_first_section(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3718   PyObject *resultobj = 0;
3719   param *arg1 = (param *) 0 ;
3720   struct param_section *result = 0 ;
3721   void *argp1 = 0 ;
3722   int res1 = 0 ;
3723   PyObject *swig_obj[1] ;
3724
3725   if (!args) SWIG_fail;
3726   swig_obj[0] = args;
3727   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_param_context, 0 |  0 );
3728   if (!SWIG_IsOK(res1)) {
3729     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamFile_first_section" "', argument " "1"" of type '" "param *""'");
3730   }
3731   arg1 = (param *)(argp1);
3732   result = (struct param_section *)param_first_section(arg1);
3733   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_param_section, 0 |  0 );
3734   return resultobj;
3735 fail:
3736   return NULL;
3737 }
3738
3739
3740 SWIGINTERN PyObject *_wrap_ParamFile_next_section(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3741   PyObject *resultobj = 0;
3742   param *arg1 = (param *) 0 ;
3743   struct param_section *arg2 = (struct param_section *) 0 ;
3744   struct param_section *result = 0 ;
3745   void *argp1 = 0 ;
3746   int res1 = 0 ;
3747   void *argp2 = 0 ;
3748   int res2 = 0 ;
3749   PyObject * obj0 = 0 ;
3750   PyObject * obj1 = 0 ;
3751   char *  kwnames[] = {
3752     (char *) "self",(char *) "s", NULL
3753   };
3754
3755   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ParamFile_next_section",kwnames,&obj0,&obj1)) SWIG_fail;
3756   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 |  0 );
3757   if (!SWIG_IsOK(res1)) {
3758     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamFile_next_section" "', argument " "1"" of type '" "param *""'");
3759   }
3760   arg1 = (param *)(argp1);
3761   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_param_section, 0 |  0 );
3762   if (!SWIG_IsOK(res2)) {
3763     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParamFile_next_section" "', argument " "2"" of type '" "struct param_section *""'");
3764   }
3765   arg2 = (struct param_section *)(argp2);
3766   result = (struct param_section *)param_next_section(arg1,arg2);
3767   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_param_section, 0 |  0 );
3768   return resultobj;
3769 fail:
3770   return NULL;
3771 }
3772
3773
3774 SWIGINTERN PyObject *_wrap_ParamFile_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3775   PyObject *resultobj = 0;
3776   param *arg1 = (param *) 0 ;
3777   char *arg2 = (char *) 0 ;
3778   int result;
3779   void *argp1 = 0 ;
3780   int res1 = 0 ;
3781   int res2 ;
3782   char *buf2 = 0 ;
3783   int alloc2 = 0 ;
3784   PyObject * obj0 = 0 ;
3785   PyObject * obj1 = 0 ;
3786   char *  kwnames[] = {
3787     (char *) "self",(char *) "fn", NULL
3788   };
3789
3790   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ParamFile_read",kwnames,&obj0,&obj1)) SWIG_fail;
3791   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 |  0 );
3792   if (!SWIG_IsOK(res1)) {
3793     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamFile_read" "', argument " "1"" of type '" "param *""'");
3794   }
3795   arg1 = (param *)(argp1);
3796   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3797   if (!SWIG_IsOK(res2)) {
3798     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParamFile_read" "', argument " "2"" of type '" "char const *""'");
3799   }
3800   arg2 = (char *)(buf2);
3801   result = (int)param_read(arg1,(char const *)arg2);
3802   resultobj = SWIG_From_int((int)(result));
3803   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3804   return resultobj;
3805 fail:
3806   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3807   return NULL;
3808 }
3809
3810
3811 SWIGINTERN PyObject *_wrap_ParamFile_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3812   PyObject *resultobj = 0;
3813   param *arg1 = (param *) 0 ;
3814   char *arg2 = (char *) 0 ;
3815   int result;
3816   void *argp1 = 0 ;
3817   int res1 = 0 ;
3818   int res2 ;
3819   char *buf2 = 0 ;
3820   int alloc2 = 0 ;
3821   PyObject * obj0 = 0 ;
3822   PyObject * obj1 = 0 ;
3823   char *  kwnames[] = {
3824     (char *) "self",(char *) "fn", NULL
3825   };
3826
3827   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ParamFile_write",kwnames,&obj0,&obj1)) SWIG_fail;
3828   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_context, 0 |  0 );
3829   if (!SWIG_IsOK(res1)) {
3830     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParamFile_write" "', argument " "1"" of type '" "param *""'");
3831   }
3832   arg1 = (param *)(argp1);
3833   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3834   if (!SWIG_IsOK(res2)) {
3835     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParamFile_write" "', argument " "2"" of type '" "char const *""'");
3836   }
3837   arg2 = (char *)(buf2);
3838   result = (int)param_write(arg1,(char const *)arg2);
3839   resultobj = SWIG_From_int((int)(result));
3840   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3841   return resultobj;
3842 fail:
3843   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3844   return NULL;
3845 }
3846
3847
3848 SWIGINTERN PyObject *_wrap_delete_ParamFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3849   PyObject *resultobj = 0;
3850   param *arg1 = (param *) 0 ;
3851   void *argp1 = 0 ;
3852   int res1 = 0 ;
3853   PyObject *swig_obj[1] ;
3854
3855   if (!args) SWIG_fail;
3856   swig_obj[0] = args;
3857   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_param_context, SWIG_POINTER_DISOWN |  0 );
3858   if (!SWIG_IsOK(res1)) {
3859     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ParamFile" "', argument " "1"" of type '" "param *""'");
3860   }
3861   arg1 = (param *)(argp1);
3862   delete_param(arg1);
3863
3864   resultobj = SWIG_Py_Void();
3865   return resultobj;
3866 fail:
3867   return NULL;
3868 }
3869
3870
3871 SWIGINTERN PyObject *ParamFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3872   PyObject *obj;
3873   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3874   SWIG_TypeNewClientData(SWIGTYPE_p_param_context, SWIG_NewClientData(obj));
3875   return SWIG_Py_Void();
3876 }
3877
3878 SWIGINTERN PyObject *ParamFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3879   return SWIG_Python_InitShadowInstance(args);
3880 }
3881
3882 SWIGINTERN PyObject *_wrap_param_opt_key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3883   PyObject *resultobj = 0;
3884   param_opt *arg1 = (param_opt *) 0 ;
3885   char *result = 0 ;
3886   void *argp1 = 0 ;
3887   int res1 = 0 ;
3888   PyObject *swig_obj[1] ;
3889
3890   if (!args) SWIG_fail;
3891   swig_obj[0] = args;
3892   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_param_opt, 0 |  0 );
3893   if (!SWIG_IsOK(res1)) {
3894     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_opt_key_get" "', argument " "1"" of type '" "param_opt *""'");
3895   }
3896   arg1 = (param_opt *)(argp1);
3897   result = (char *) ((arg1)->key);
3898   resultobj = SWIG_FromCharPtr((const char *)result);
3899   return resultobj;
3900 fail:
3901   return NULL;
3902 }
3903
3904
3905 SWIGINTERN PyObject *_wrap_param_opt_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3906   PyObject *resultobj = 0;
3907   param_opt *arg1 = (param_opt *) 0 ;
3908   char *result = 0 ;
3909   void *argp1 = 0 ;
3910   int res1 = 0 ;
3911   PyObject *swig_obj[1] ;
3912
3913   if (!args) SWIG_fail;
3914   swig_obj[0] = args;
3915   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_param_opt, 0 |  0 );
3916   if (!SWIG_IsOK(res1)) {
3917     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_opt_value_get" "', argument " "1"" of type '" "param_opt *""'");
3918   }
3919   arg1 = (param_opt *)(argp1);
3920   result = (char *) ((arg1)->value);
3921   resultobj = SWIG_FromCharPtr((const char *)result);
3922   return resultobj;
3923 fail:
3924   return NULL;
3925 }
3926
3927
3928 SWIGINTERN PyObject *_wrap_param_opt___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3929   PyObject *resultobj = 0;
3930   param_opt *arg1 = (param_opt *) 0 ;
3931   char *result = 0 ;
3932   void *argp1 = 0 ;
3933   int res1 = 0 ;
3934   PyObject *swig_obj[1] ;
3935
3936   if (!args) SWIG_fail;
3937   swig_obj[0] = args;
3938   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_param_opt, 0 |  0 );
3939   if (!SWIG_IsOK(res1)) {
3940     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_opt___str__" "', argument " "1"" of type '" "param_opt *""'");
3941   }
3942   arg1 = (param_opt *)(argp1);
3943   result = (char *)param_opt___str__(arg1);
3944   resultobj = SWIG_FromCharPtr((const char *)result);
3945   return resultobj;
3946 fail:
3947   return NULL;
3948 }
3949
3950
3951 SWIGINTERN PyObject *_wrap_delete_param_opt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3952   PyObject *resultobj = 0;
3953   param_opt *arg1 = (param_opt *) 0 ;
3954   void *argp1 = 0 ;
3955   int res1 = 0 ;
3956   PyObject *swig_obj[1] ;
3957
3958   if (!args) SWIG_fail;
3959   swig_obj[0] = args;
3960   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_param_opt, SWIG_POINTER_DISOWN |  0 );
3961   if (!SWIG_IsOK(res1)) {
3962     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_param_opt" "', argument " "1"" of type '" "param_opt *""'");
3963   }
3964   arg1 = (param_opt *)(argp1);
3965   delete_param_opt(arg1);
3966
3967   resultobj = SWIG_Py_Void();
3968   return resultobj;
3969 fail:
3970   return NULL;
3971 }
3972
3973
3974 SWIGINTERN PyObject *param_opt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3975   PyObject *obj;
3976   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3977   SWIG_TypeNewClientData(SWIGTYPE_p_param_opt, SWIG_NewClientData(obj));
3978   return SWIG_Py_Void();
3979 }
3980
3981 SWIGINTERN PyObject *_wrap_param_section_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3982   PyObject *resultobj = 0;
3983   param_section *arg1 = (param_section *) 0 ;
3984   char *result = 0 ;
3985   void *argp1 = 0 ;
3986   int res1 = 0 ;
3987   PyObject *swig_obj[1] ;
3988
3989   if (!args) SWIG_fail;
3990   swig_obj[0] = args;
3991   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_param_section, 0 |  0 );
3992   if (!SWIG_IsOK(res1)) {
3993     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_section_name_get" "', argument " "1"" of type '" "param_section *""'");
3994   }
3995   arg1 = (param_section *)(argp1);
3996   result = (char *) ((arg1)->name);
3997   resultobj = SWIG_FromCharPtr((const char *)result);
3998   return resultobj;
3999 fail:
4000   return NULL;
4001 }
4002
4003
4004 SWIGINTERN PyObject *_wrap_param_section_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4005   PyObject *resultobj = 0;
4006   param_section *arg1 = (param_section *) 0 ;
4007   char *arg2 = (char *) 0 ;
4008   struct param_opt *result = 0 ;
4009   void *argp1 = 0 ;
4010   int res1 = 0 ;
4011   int res2 ;
4012   char *buf2 = 0 ;
4013   int alloc2 = 0 ;
4014   PyObject * obj0 = 0 ;
4015   PyObject * obj1 = 0 ;
4016   char *  kwnames[] = {
4017     (char *) "self",(char *) "name", NULL
4018   };
4019
4020   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:param_section_get",kwnames,&obj0,&obj1)) SWIG_fail;
4021   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_section, 0 |  0 );
4022   if (!SWIG_IsOK(res1)) {
4023     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_section_get" "', argument " "1"" of type '" "param_section *""'");
4024   }
4025   arg1 = (param_section *)(argp1);
4026   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4027   if (!SWIG_IsOK(res2)) {
4028     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "param_section_get" "', argument " "2"" of type '" "char const *""'");
4029   }
4030   arg2 = (char *)(buf2);
4031   result = (struct param_opt *)param_section_get(arg1,(char const *)arg2);
4032   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_param_opt, 0 |  0 );
4033   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4034   return resultobj;
4035 fail:
4036   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4037   return NULL;
4038 }
4039
4040
4041 SWIGINTERN PyObject *_wrap_param_section_first_parameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4042   PyObject *resultobj = 0;
4043   param_section *arg1 = (param_section *) 0 ;
4044   struct param_opt *result = 0 ;
4045   void *argp1 = 0 ;
4046   int res1 = 0 ;
4047   PyObject *swig_obj[1] ;
4048
4049   if (!args) SWIG_fail;
4050   swig_obj[0] = args;
4051   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_param_section, 0 |  0 );
4052   if (!SWIG_IsOK(res1)) {
4053     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_section_first_parameter" "', argument " "1"" of type '" "param_section *""'");
4054   }
4055   arg1 = (param_section *)(argp1);
4056   result = (struct param_opt *)param_section_first_parameter(arg1);
4057   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_param_opt, 0 |  0 );
4058   return resultobj;
4059 fail:
4060   return NULL;
4061 }
4062
4063
4064 SWIGINTERN PyObject *_wrap_param_section_next_parameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4065   PyObject *resultobj = 0;
4066   param_section *arg1 = (param_section *) 0 ;
4067   struct param_opt *arg2 = (struct param_opt *) 0 ;
4068   struct param_opt *result = 0 ;
4069   void *argp1 = 0 ;
4070   int res1 = 0 ;
4071   void *argp2 = 0 ;
4072   int res2 = 0 ;
4073   PyObject * obj0 = 0 ;
4074   PyObject * obj1 = 0 ;
4075   char *  kwnames[] = {
4076     (char *) "self",(char *) "s", NULL
4077   };
4078
4079   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:param_section_next_parameter",kwnames,&obj0,&obj1)) SWIG_fail;
4080   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_param_section, 0 |  0 );
4081   if (!SWIG_IsOK(res1)) {
4082     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_section_next_parameter" "', argument " "1"" of type '" "param_section *""'");
4083   }
4084   arg1 = (param_section *)(argp1);
4085   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_param_opt, 0 |  0 );
4086   if (!SWIG_IsOK(res2)) {
4087     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "param_section_next_parameter" "', argument " "2"" of type '" "struct param_opt *""'");
4088   }
4089   arg2 = (struct param_opt *)(argp2);
4090   result = (struct param_opt *)param_section_next_parameter(arg1,arg2);
4091   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_param_opt, 0 |  0 );
4092   return resultobj;
4093 fail:
4094   return NULL;
4095 }
4096
4097
4098 SWIGINTERN PyObject *_wrap_new_param_section(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4099   PyObject *resultobj = 0;
4100   param_section *result = 0 ;
4101
4102   if (!SWIG_Python_UnpackTuple(args,"new_param_section",0,0,0)) SWIG_fail;
4103   result = (param_section *)calloc(1, sizeof(param_section));
4104   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_param_section, SWIG_POINTER_NEW |  0 );
4105   return resultobj;
4106 fail:
4107   return NULL;
4108 }
4109
4110
4111 SWIGINTERN PyObject *_wrap_delete_param_section(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4112   PyObject *resultobj = 0;
4113   param_section *arg1 = (param_section *) 0 ;
4114   void *argp1 = 0 ;
4115   int res1 = 0 ;
4116   PyObject *swig_obj[1] ;
4117
4118   if (!args) SWIG_fail;
4119   swig_obj[0] = args;
4120   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_param_section, SWIG_POINTER_DISOWN |  0 );
4121   if (!SWIG_IsOK(res1)) {
4122     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_param_section" "', argument " "1"" of type '" "param_section *""'");
4123   }
4124   arg1 = (param_section *)(argp1);
4125   free((char *) arg1);
4126
4127   resultobj = SWIG_Py_Void();
4128   return resultobj;
4129 fail:
4130   return NULL;
4131 }
4132
4133
4134 SWIGINTERN PyObject *param_section_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4135   PyObject *obj;
4136   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4137   SWIG_TypeNewClientData(SWIGTYPE_p_param_section, SWIG_NewClientData(obj));
4138   return SWIG_Py_Void();
4139 }
4140
4141 SWIGINTERN PyObject *param_section_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4142   return SWIG_Python_InitShadowInstance(args);
4143 }
4144
4145 SWIGINTERN int Swig_var_default_config_set(PyObject *_val) {
4146   {
4147     void *argp = 0;
4148     int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_loadparm_context,  0 );
4149     if (!SWIG_IsOK(res)) {
4150       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""global_loadparm""' of type '""struct loadparm_context *""'");
4151     }
4152     global_loadparm = (struct loadparm_context *)(argp);
4153   }
4154   return 0;
4155 fail:
4156   return 1;
4157 }
4158
4159
4160 SWIGINTERN PyObject *Swig_var_default_config_get(void) {
4161   PyObject *pyobj = 0;
4162
4163   pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(global_loadparm), SWIGTYPE_p_loadparm_context,  0 );
4164   return pyobj;
4165 }
4166
4167
4168 static PyMethodDef SwigMethods[] = {
4169          { (char *)"new_LoadParm", (PyCFunction)_wrap_new_LoadParm, METH_NOARGS, NULL},
4170          { (char *)"LoadParm_default_service", (PyCFunction) _wrap_LoadParm_default_service, METH_VARARGS | METH_KEYWORDS, NULL},
4171          { (char *)"LoadParm_load", (PyCFunction) _wrap_LoadParm_load, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
4172                 "S.load(filename) -> None\n"
4173                 "Load specified file.\n"
4174                 ""},
4175          { (char *)"LoadParm_load_default", (PyCFunction) _wrap_LoadParm_load_default, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
4176                 "S.load_default() -> None\n"
4177                 "Load default smb.conf file.\n"
4178                 ""},
4179          { (char *)"LoadParm___len__", (PyCFunction) _wrap_LoadParm___len__, METH_VARARGS | METH_KEYWORDS, NULL},
4180          { (char *)"LoadParm___getitem__", (PyCFunction) _wrap_LoadParm___getitem__, METH_VARARGS | METH_KEYWORDS, NULL},
4181          { (char *)"LoadParm_configfile", (PyCFunction) _wrap_LoadParm_configfile, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
4182                 "S.configfile() -> string\n"
4183                 "Return name of last config file that was loaded.\n"
4184                 ""},
4185          { (char *)"LoadParm_is_mydomain", (PyCFunction) _wrap_LoadParm_is_mydomain, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
4186                 "S.is_mydomain(domain_name) -> bool\n"
4187                 "Check whether the specified name matches our domain name.\n"
4188                 ""},
4189          { (char *)"LoadParm_is_myname", (PyCFunction) _wrap_LoadParm_is_myname, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
4190                 "S.is_myname(netbios_name) -> bool\n"
4191                 "Check whether the specified name matches one of our netbios names.\n"
4192                 ""},
4193          { (char *)"LoadParm_use", (PyCFunction) _wrap_LoadParm_use, METH_VARARGS | METH_KEYWORDS, NULL},
4194          { (char *)"LoadParm_set", (PyCFunction) _wrap_LoadParm_set, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
4195                 "S.set(name, value) -> bool\n"
4196                 "Change a parameter.\n"
4197                 ""},
4198          { (char *)"LoadParm_get", (PyCFunction) _wrap_LoadParm_get, METH_VARARGS | METH_KEYWORDS, NULL},
4199          { (char *)"delete_LoadParm", (PyCFunction) _wrap_delete_LoadParm, METH_VARARGS | METH_KEYWORDS, NULL},
4200          { (char *)"LoadParm_swigregister", LoadParm_swigregister, METH_VARARGS, NULL},
4201          { (char *)"LoadParm_swiginit", LoadParm_swiginit, METH_VARARGS, NULL},
4202          { (char *)"loadparm_service_volume_label", (PyCFunction) _wrap_loadparm_service_volume_label, METH_VARARGS | METH_KEYWORDS, NULL},
4203          { (char *)"loadparm_service_printername", (PyCFunction) _wrap_loadparm_service_printername, METH_VARARGS | METH_KEYWORDS, NULL},
4204          { (char *)"loadparm_service_maxprintjobs", (PyCFunction) _wrap_loadparm_service_maxprintjobs, METH_VARARGS | METH_KEYWORDS, NULL},
4205          { (char *)"loadparm_service_swigregister", loadparm_service_swigregister, METH_VARARGS, NULL},
4206          { (char *)"new_ParamFile", (PyCFunction)_wrap_new_ParamFile, METH_NOARGS, NULL},
4207          { (char *)"ParamFile_get_section", (PyCFunction) _wrap_ParamFile_get_section, METH_VARARGS | METH_KEYWORDS, NULL},
4208          { (char *)"ParamFile_add_section", (PyCFunction) _wrap_ParamFile_add_section, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
4209                 "S.add_section(name) -> section\n"
4210                 "Add a new section.\n"
4211                 ""},
4212          { (char *)"ParamFile_get", (PyCFunction) _wrap_ParamFile_get, METH_VARARGS | METH_KEYWORDS, NULL},
4213          { (char *)"ParamFile_get_string", (PyCFunction) _wrap_ParamFile_get_string, METH_VARARGS | METH_KEYWORDS, NULL},
4214          { (char *)"ParamFile_set_string", (PyCFunction) _wrap_ParamFile_set_string, METH_VARARGS | METH_KEYWORDS, NULL},
4215          { (char *)"ParamFile_set", (PyCFunction) _wrap_ParamFile_set, METH_VARARGS | METH_KEYWORDS, NULL},
4216          { (char *)"ParamFile_first_section", (PyCFunction)_wrap_ParamFile_first_section, METH_O, (char *)"\n"
4217                 "S.first_section() -> section\n"
4218                 "Find first section\n"
4219                 ""},
4220          { (char *)"ParamFile_next_section", (PyCFunction) _wrap_ParamFile_next_section, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
4221                 "S.next_section(prev) -> section\n"
4222                 "Find next section\n"
4223                 ""},
4224          { (char *)"ParamFile_read", (PyCFunction) _wrap_ParamFile_read, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
4225                 "S.read(filename) -> bool\n"
4226                 "Read a filename.\n"
4227                 ""},
4228          { (char *)"ParamFile_write", (PyCFunction) _wrap_ParamFile_write, METH_VARARGS | METH_KEYWORDS, NULL},
4229          { (char *)"delete_ParamFile", (PyCFunction)_wrap_delete_ParamFile, METH_O, NULL},
4230          { (char *)"ParamFile_swigregister", ParamFile_swigregister, METH_VARARGS, NULL},
4231          { (char *)"ParamFile_swiginit", ParamFile_swiginit, METH_VARARGS, NULL},
4232          { (char *)"param_opt_key_get", (PyCFunction)_wrap_param_opt_key_get, METH_O, NULL},
4233          { (char *)"param_opt_value_get", (PyCFunction)_wrap_param_opt_value_get, METH_O, NULL},
4234          { (char *)"param_opt___str__", (PyCFunction)_wrap_param_opt___str__, METH_O, NULL},
4235          { (char *)"delete_param_opt", (PyCFunction)_wrap_delete_param_opt, METH_O, NULL},
4236          { (char *)"param_opt_swigregister", param_opt_swigregister, METH_VARARGS, NULL},
4237          { (char *)"param_section_name_get", (PyCFunction)_wrap_param_section_name_get, METH_O, NULL},
4238          { (char *)"param_section_get", (PyCFunction) _wrap_param_section_get, METH_VARARGS | METH_KEYWORDS, NULL},
4239          { (char *)"param_section_first_parameter", (PyCFunction)_wrap_param_section_first_parameter, METH_O, NULL},
4240          { (char *)"param_section_next_parameter", (PyCFunction) _wrap_param_section_next_parameter, METH_VARARGS | METH_KEYWORDS, NULL},
4241          { (char *)"new_param_section", (PyCFunction)_wrap_new_param_section, METH_NOARGS, NULL},
4242          { (char *)"delete_param_section", (PyCFunction)_wrap_delete_param_section, METH_O, NULL},
4243          { (char *)"param_section_swigregister", param_section_swigregister, METH_VARARGS, NULL},
4244          { (char *)"param_section_swiginit", param_section_swiginit, METH_VARARGS, NULL},
4245          { NULL, NULL, 0, NULL }
4246 };
4247
4248
4249 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4250
4251 static swig_type_info _swigt__p_TALLOC_CTX = {"_p_TALLOC_CTX", "TALLOC_CTX *", 0, 0, (void*)0, 0};
4252 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
4253 static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0};
4254 static swig_type_info _swigt__p_loadparm_context = {"_p_loadparm_context", "struct loadparm_context *|loadparm_context *", 0, 0, (void*)0, 0};
4255 static swig_type_info _swigt__p_loadparm_service = {"_p_loadparm_service", "struct loadparm_service *|loadparm_service *", 0, 0, (void*)0, 0};
4256 static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
4257 static swig_type_info _swigt__p_param_context = {"_p_param_context", "struct param_context *|param *", 0, 0, (void*)0, 0};
4258 static swig_type_info _swigt__p_param_opt = {"_p_param_opt", "struct param_opt *|param_opt *", 0, 0, (void*)0, 0};
4259 static swig_type_info _swigt__p_param_section = {"_p_param_section", "struct param_section *|param_section *", 0, 0, (void*)0, 0};
4260 static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
4261 static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
4262 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
4263 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
4264 static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
4265 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
4266
4267 static swig_type_info *swig_type_initial[] = {
4268   &_swigt__p_TALLOC_CTX,
4269   &_swigt__p_char,
4270   &_swigt__p_int,
4271   &_swigt__p_loadparm_context,
4272   &_swigt__p_loadparm_service,
4273   &_swigt__p_long_long,
4274   &_swigt__p_param_context,
4275   &_swigt__p_param_opt,
4276   &_swigt__p_param_section,
4277   &_swigt__p_short,
4278   &_swigt__p_signed_char,
4279   &_swigt__p_unsigned_char,
4280   &_swigt__p_unsigned_int,
4281   &_swigt__p_unsigned_long_long,
4282   &_swigt__p_unsigned_short,
4283 };
4284
4285 static swig_cast_info _swigc__p_TALLOC_CTX[] = {  {&_swigt__p_TALLOC_CTX, 0, 0, 0},{0, 0, 0, 0}};
4286 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
4287 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
4288 static swig_cast_info _swigc__p_loadparm_context[] = {  {&_swigt__p_loadparm_context, 0, 0, 0},{0, 0, 0, 0}};
4289 static swig_cast_info _swigc__p_loadparm_service[] = {  {&_swigt__p_loadparm_service, 0, 0, 0},{0, 0, 0, 0}};
4290 static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
4291 static swig_cast_info _swigc__p_param_context[] = {  {&_swigt__p_param_context, 0, 0, 0},{0, 0, 0, 0}};
4292 static swig_cast_info _swigc__p_param_opt[] = {  {&_swigt__p_param_opt, 0, 0, 0},{0, 0, 0, 0}};
4293 static swig_cast_info _swigc__p_param_section[] = {  {&_swigt__p_param_section, 0, 0, 0},{0, 0, 0, 0}};
4294 static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
4295 static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
4296 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
4297 static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
4298 static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
4299 static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
4300
4301 static swig_cast_info *swig_cast_initial[] = {
4302   _swigc__p_TALLOC_CTX,
4303   _swigc__p_char,
4304   _swigc__p_int,
4305   _swigc__p_loadparm_context,
4306   _swigc__p_loadparm_service,
4307   _swigc__p_long_long,
4308   _swigc__p_param_context,
4309   _swigc__p_param_opt,
4310   _swigc__p_param_section,
4311   _swigc__p_short,
4312   _swigc__p_signed_char,
4313   _swigc__p_unsigned_char,
4314   _swigc__p_unsigned_int,
4315   _swigc__p_unsigned_long_long,
4316   _swigc__p_unsigned_short,
4317 };
4318
4319
4320 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4321
4322 static swig_const_info swig_const_table[] = {
4323 {0, 0, 0, 0.0, 0, 0}};
4324
4325 #ifdef __cplusplus
4326 }
4327 #endif
4328 /* -----------------------------------------------------------------------------
4329  * Type initialization:
4330  * This problem is tough by the requirement that no dynamic
4331  * memory is used. Also, since swig_type_info structures store pointers to
4332  * swig_cast_info structures and swig_cast_info structures store pointers back
4333  * to swig_type_info structures, we need some lookup code at initialization.
4334  * The idea is that swig generates all the structures that are needed.
4335  * The runtime then collects these partially filled structures.
4336  * The SWIG_InitializeModule function takes these initial arrays out of
4337  * swig_module, and does all the lookup, filling in the swig_module.types
4338  * array with the correct data and linking the correct swig_cast_info
4339  * structures together.
4340  *
4341  * The generated swig_type_info structures are assigned staticly to an initial
4342  * array. We just loop through that array, and handle each type individually.
4343  * First we lookup if this type has been already loaded, and if so, use the
4344  * loaded structure instead of the generated one. Then we have to fill in the
4345  * cast linked list. The cast data is initially stored in something like a
4346  * two-dimensional array. Each row corresponds to a type (there are the same
4347  * number of rows as there are in the swig_type_initial array). Each entry in
4348  * a column is one of the swig_cast_info structures for that type.
4349  * The cast_initial array is actually an array of arrays, because each row has
4350  * a variable number of columns. So to actually build the cast linked list,
4351  * we find the array of casts associated with the type, and loop through it
4352  * adding the casts to the list. The one last trick we need to do is making
4353  * sure the type pointer in the swig_cast_info struct is correct.
4354  *
4355  * First off, we lookup the cast->type name to see if it is already loaded.
4356  * There are three cases to handle:
4357  *  1) If the cast->type has already been loaded AND the type we are adding
4358  *     casting info to has not been loaded (it is in this module), THEN we
4359  *     replace the cast->type pointer with the type pointer that has already
4360  *     been loaded.
4361  *  2) If BOTH types (the one we are adding casting info to, and the
4362  *     cast->type) are loaded, THEN the cast info has already been loaded by
4363  *     the previous module so we just ignore it.
4364  *  3) Finally, if cast->type has not already been loaded, then we add that
4365  *     swig_cast_info to the linked list (because the cast->type) pointer will
4366  *     be correct.
4367  * ----------------------------------------------------------------------------- */
4368
4369 #ifdef __cplusplus
4370 extern "C" {
4371 #if 0
4372 } /* c-mode */
4373 #endif
4374 #endif
4375
4376 #if 0
4377 #define SWIGRUNTIME_DEBUG
4378 #endif
4379
4380
4381 SWIGRUNTIME void
4382 SWIG_InitializeModule(void *clientdata) {
4383   size_t i;
4384   swig_module_info *module_head, *iter;
4385   int found, init;
4386
4387   clientdata = clientdata;
4388
4389   /* check to see if the circular list has been setup, if not, set it up */
4390   if (swig_module.next==0) {
4391     /* Initialize the swig_module */
4392     swig_module.type_initial = swig_type_initial;
4393     swig_module.cast_initial = swig_cast_initial;
4394     swig_module.next = &swig_module;
4395     init = 1;
4396   } else {
4397     init = 0;
4398   }
4399
4400   /* Try and load any already created modules */
4401   module_head = SWIG_GetModule(clientdata);
4402   if (!module_head) {
4403     /* This is the first module loaded for this interpreter */
4404     /* so set the swig module into the interpreter */
4405     SWIG_SetModule(clientdata, &swig_module);
4406     module_head = &swig_module;
4407   } else {
4408     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4409     found=0;
4410     iter=module_head;
4411     do {
4412       if (iter==&swig_module) {
4413         found=1;
4414         break;
4415       }
4416       iter=iter->next;
4417     } while (iter!= module_head);
4418
4419     /* if the is found in the list, then all is done and we may leave */
4420     if (found) return;
4421     /* otherwise we must add out module into the list */
4422     swig_module.next = module_head->next;
4423     module_head->next = &swig_module;
4424   }
4425
4426   /* When multiple interpeters are used, a module could have already been initialized in
4427        a different interpreter, but not yet have a pointer in this interpreter.
4428        In this case, we do not want to continue adding types... everything should be
4429        set up already */
4430   if (init == 0) return;
4431
4432   /* Now work on filling in swig_module.types */
4433 #ifdef SWIGRUNTIME_DEBUG
4434   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
4435 #endif
4436   for (i = 0; i < swig_module.size; ++i) {
4437     swig_type_info *type = 0;
4438     swig_type_info *ret;
4439     swig_cast_info *cast;
4440
4441 #ifdef SWIGRUNTIME_DEBUG
4442     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4443 #endif
4444
4445     /* if there is another module already loaded */
4446     if (swig_module.next != &swig_module) {
4447       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4448     }
4449     if (type) {
4450       /* Overwrite clientdata field */
4451 #ifdef SWIGRUNTIME_DEBUG
4452       printf("SWIG_InitializeModule: found type %s\n", type->name);
4453 #endif
4454       if (swig_module.type_initial[i]->clientdata) {
4455         type->clientdata = swig_module.type_initial[i]->clientdata;
4456 #ifdef SWIGRUNTIME_DEBUG
4457         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
4458 #endif
4459       }
4460     } else {
4461       type = swig_module.type_initial[i];
4462     }
4463
4464     /* Insert casting types */
4465     cast = swig_module.cast_initial[i];
4466     while (cast->type) {
4467       /* Don't need to add information already in the list */
4468       ret = 0;
4469 #ifdef SWIGRUNTIME_DEBUG
4470       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4471 #endif
4472       if (swig_module.next != &swig_module) {
4473         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4474 #ifdef SWIGRUNTIME_DEBUG
4475         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4476 #endif
4477       }
4478       if (ret) {
4479         if (type == swig_module.type_initial[i]) {
4480 #ifdef SWIGRUNTIME_DEBUG
4481           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4482 #endif
4483           cast->type = ret;
4484           ret = 0;
4485         } else {
4486           /* Check for casting already in the list */
4487           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4488 #ifdef SWIGRUNTIME_DEBUG
4489           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4490 #endif
4491           if (!ocast) ret = 0;
4492         }
4493       }
4494
4495       if (!ret) {
4496 #ifdef SWIGRUNTIME_DEBUG
4497         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4498 #endif
4499         if (type->cast) {
4500           type->cast->prev = cast;
4501           cast->next = type->cast;
4502         }
4503         type->cast = cast;
4504       }
4505       cast++;
4506     }
4507     /* Set entry in modules->types array equal to the type */
4508     swig_module.types[i] = type;
4509   }
4510   swig_module.types[i] = 0;
4511
4512 #ifdef SWIGRUNTIME_DEBUG
4513   printf("**** SWIG_InitializeModule: Cast List ******\n");
4514   for (i = 0; i < swig_module.size; ++i) {
4515     int j = 0;
4516     swig_cast_info *cast = swig_module.cast_initial[i];
4517     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4518     while (cast->type) {
4519       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4520       cast++;
4521       ++j;
4522     }
4523     printf("---- Total casts: %d\n",j);
4524   }
4525   printf("**** SWIG_InitializeModule: Cast List ******\n");
4526 #endif
4527 }
4528
4529 /* This function will propagate the clientdata field of type to
4530 * any new swig_type_info structures that have been added into the list
4531 * of equivalent types.  It is like calling
4532 * SWIG_TypeClientData(type, clientdata) a second time.
4533 */
4534 SWIGRUNTIME void
4535 SWIG_PropagateClientData(void) {
4536   size_t i;
4537   swig_cast_info *equiv;
4538   static int init_run = 0;
4539
4540   if (init_run) return;
4541   init_run = 1;
4542
4543   for (i = 0; i < swig_module.size; i++) {
4544     if (swig_module.types[i]->clientdata) {
4545       equiv = swig_module.types[i]->cast;
4546       while (equiv) {
4547         if (!equiv->converter) {
4548           if (equiv->type && !equiv->type->clientdata)
4549           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4550         }
4551         equiv = equiv->next;
4552       }
4553     }
4554   }
4555 }
4556
4557 #ifdef __cplusplus
4558 #if 0
4559 {
4560   /* c-mode */
4561 #endif
4562 }
4563 #endif
4564
4565
4566
4567 #ifdef __cplusplus
4568 extern "C" {
4569 #endif
4570
4571   /* Python-specific SWIG API */
4572 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
4573 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
4574 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
4575
4576   /* -----------------------------------------------------------------------------
4577    * global variable support code.
4578    * ----------------------------------------------------------------------------- */
4579
4580   typedef struct swig_globalvar {
4581     char       *name;                  /* Name of global variable */
4582     PyObject *(*get_attr)(void);       /* Return the current value */
4583     int       (*set_attr)(PyObject *); /* Set the value */
4584     struct swig_globalvar *next;
4585   } swig_globalvar;
4586
4587   typedef struct swig_varlinkobject {
4588     PyObject_HEAD
4589     swig_globalvar *vars;
4590   } swig_varlinkobject;
4591
4592   SWIGINTERN PyObject *
4593   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
4594     return PyString_FromString("<Swig global variables>");
4595   }
4596
4597   SWIGINTERN PyObject *
4598   swig_varlink_str(swig_varlinkobject *v) {
4599     PyObject *str = PyString_FromString("(");
4600     swig_globalvar  *var;
4601     for (var = v->vars; var; var=var->next) {
4602       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
4603       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
4604     }
4605     PyString_ConcatAndDel(&str,PyString_FromString(")"));
4606     return str;
4607   }
4608
4609   SWIGINTERN int
4610   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
4611     PyObject *str = swig_varlink_str(v);
4612     fprintf(fp,"Swig global variables ");
4613     fprintf(fp,"%s\n", PyString_AsString(str));
4614     Py_DECREF(str);
4615     return 0;
4616   }
4617
4618   SWIGINTERN void
4619   swig_varlink_dealloc(swig_varlinkobject *v) {
4620     swig_globalvar *var = v->vars;
4621     while (var) {
4622       swig_globalvar *n = var->next;
4623       free(var->name);
4624       free(var);
4625       var = n;
4626     }
4627   }
4628
4629   SWIGINTERN PyObject *
4630   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
4631     PyObject *res = NULL;
4632     swig_globalvar *var = v->vars;
4633     while (var) {
4634       if (strcmp(var->name,n) == 0) {
4635         res = (*var->get_attr)();
4636         break;
4637       }
4638       var = var->next;
4639     }
4640     if (res == NULL && !PyErr_Occurred()) {
4641       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
4642     }
4643     return res;
4644   }
4645
4646   SWIGINTERN int
4647   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
4648     int res = 1;
4649     swig_globalvar *var = v->vars;
4650     while (var) {
4651       if (strcmp(var->name,n) == 0) {
4652         res = (*var->set_attr)(p);
4653         break;
4654       }
4655       var = var->next;
4656     }
4657     if (res == 1 && !PyErr_Occurred()) {
4658       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
4659     }
4660     return res;
4661   }
4662
4663   SWIGINTERN PyTypeObject*
4664   swig_varlink_type(void) {
4665     static char varlink__doc__[] = "Swig var link object";
4666     static PyTypeObject varlink_type;
4667     static int type_init = 0;
4668     if (!type_init) {
4669       const PyTypeObject tmp
4670       = {
4671         PyObject_HEAD_INIT(NULL)
4672         0,                                  /* Number of items in variable part (ob_size) */
4673         (char *)"swigvarlink",              /* Type name (tp_name) */
4674         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
4675         0,                                  /* Itemsize (tp_itemsize) */
4676         (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */
4677         (printfunc) swig_varlink_print,     /* Print (tp_print) */
4678         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
4679         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
4680         0,                                  /* tp_compare */
4681         (reprfunc) swig_varlink_repr,       /* tp_repr */
4682         0,                                  /* tp_as_number */
4683         0,                                  /* tp_as_sequence */
4684         0,                                  /* tp_as_mapping */
4685         0,                                  /* tp_hash */
4686         0,                                  /* tp_call */
4687         (reprfunc)swig_varlink_str,        /* tp_str */
4688         0,                                  /* tp_getattro */
4689         0,                                  /* tp_setattro */
4690         0,                                  /* tp_as_buffer */
4691         0,                                  /* tp_flags */
4692         varlink__doc__,                     /* tp_doc */
4693         0,                                  /* tp_traverse */
4694         0,                                  /* tp_clear */
4695         0,                                  /* tp_richcompare */
4696         0,                                  /* tp_weaklistoffset */
4697 #if PY_VERSION_HEX >= 0x02020000
4698         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
4699 #endif
4700 #if PY_VERSION_HEX >= 0x02030000
4701         0,                                  /* tp_del */
4702 #endif
4703 #ifdef COUNT_ALLOCS
4704         0,0,0,0                             /* tp_alloc -> tp_next */
4705 #endif
4706       };
4707       varlink_type = tmp;
4708       varlink_type.ob_type = &PyType_Type;
4709       type_init = 1;
4710     }
4711     return &varlink_type;
4712   }
4713
4714   /* Create a variable linking object for use later */
4715   SWIGINTERN PyObject *
4716   SWIG_Python_newvarlink(void) {
4717     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
4718     if (result) {
4719       result->vars = 0;
4720     }
4721     return ((PyObject*) result);
4722   }
4723
4724   SWIGINTERN void
4725   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
4726     swig_varlinkobject *v = (swig_varlinkobject *) p;
4727     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
4728     if (gv) {
4729       size_t size = strlen(name)+1;
4730       gv->name = (char *)malloc(size);
4731       if (gv->name) {
4732         strncpy(gv->name,name,size);
4733         gv->get_attr = get_attr;
4734         gv->set_attr = set_attr;
4735         gv->next = v->vars;
4736       }
4737     }
4738     v->vars = gv;
4739   }
4740
4741   SWIGINTERN PyObject *
4742   SWIG_globals(void) {
4743     static PyObject *_SWIG_globals = 0;
4744     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
4745     return _SWIG_globals;
4746   }
4747
4748   /* -----------------------------------------------------------------------------
4749    * constants/methods manipulation
4750    * ----------------------------------------------------------------------------- */
4751
4752   /* Install Constants */
4753   SWIGINTERN void
4754   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
4755     PyObject *obj = 0;
4756     size_t i;
4757     for (i = 0; constants[i].type; ++i) {
4758       switch(constants[i].type) {
4759       case SWIG_PY_POINTER:
4760         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
4761         break;
4762       case SWIG_PY_BINARY:
4763         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
4764         break;
4765       default:
4766         obj = 0;
4767         break;
4768       }
4769       if (obj) {
4770         PyDict_SetItemString(d, constants[i].name, obj);
4771         Py_DECREF(obj);
4772       }
4773     }
4774   }
4775
4776   /* -----------------------------------------------------------------------------*/
4777   /* Fix SwigMethods to carry the callback ptrs when needed */
4778   /* -----------------------------------------------------------------------------*/
4779
4780   SWIGINTERN void
4781   SWIG_Python_FixMethods(PyMethodDef *methods,
4782     swig_const_info *const_table,
4783     swig_type_info **types,
4784     swig_type_info **types_initial) {
4785     size_t i;
4786     for (i = 0; methods[i].ml_name; ++i) {
4787       const char *c = methods[i].ml_doc;
4788       if (c && (c = strstr(c, "swig_ptr: "))) {
4789         int j;
4790         swig_const_info *ci = 0;
4791         const char *name = c + 10;
4792         for (j = 0; const_table[j].type; ++j) {
4793           if (strncmp(const_table[j].name, name,
4794               strlen(const_table[j].name)) == 0) {
4795             ci = &(const_table[j]);
4796             break;
4797           }
4798         }
4799         if (ci) {
4800           size_t shift = (ci->ptype) - types;
4801           swig_type_info *ty = types_initial[shift];
4802           size_t ldoc = (c - methods[i].ml_doc);
4803           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
4804           char *ndoc = (char*)malloc(ldoc + lptr + 10);
4805           if (ndoc) {
4806             char *buff = ndoc;
4807             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
4808             if (ptr) {
4809               strncpy(buff, methods[i].ml_doc, ldoc);
4810               buff += ldoc;
4811               strncpy(buff, "swig_ptr: ", 10);
4812               buff += 10;
4813               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
4814               methods[i].ml_doc = ndoc;
4815             }
4816           }
4817         }
4818       }
4819     }
4820   }
4821
4822 #ifdef __cplusplus
4823 }
4824 #endif
4825
4826 /* -----------------------------------------------------------------------------*
4827  *  Partial Init method
4828  * -----------------------------------------------------------------------------*/
4829
4830 #ifdef __cplusplus
4831 extern "C"
4832 #endif
4833 SWIGEXPORT void SWIG_init(void) {
4834   PyObject *m, *d;
4835
4836   /* Fix SwigMethods to carry the callback ptrs when needed */
4837   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
4838
4839   m = Py_InitModule((char *) SWIG_name, SwigMethods);
4840   d = PyModule_GetDict(m);
4841
4842   SWIG_InitializeModule(0);
4843   SWIG_InstallConstants(d,swig_const_table);
4844
4845
4846   PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
4847   SWIG_addvarlink(SWIG_globals(),(char*)"default_config",Swig_var_default_config_get, Swig_var_default_config_set);
4848 }
4849