source4/param/param_wrap.c

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