source4/lib/ldb/ldb_wrap.c

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.33
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #define SWIGPYTHON
  12 #define SWIG_PYTHON_NO_BUILD_NONE
  13 /* -----------------------------------------------------------------------------
  14  *  This section contains generic SWIG labels for method/variable
  15  *  declarations/attributes, and other compiler dependent labels.
  16  * ----------------------------------------------------------------------------- */
  17
  18 /* template workaround for compilers that cannot correctly implement the C++ standard */
  19 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  20 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  21 #  define SWIGTEMPLATEDISAMBIGUATOR template
  22 # elif defined(__HP_aCC)
  23 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  24 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  25 #  define SWIGTEMPLATEDISAMBIGUATOR template
  26 # else
  27 #  define SWIGTEMPLATEDISAMBIGUATOR
  28 # endif
  29 #endif
  30
  31 /* inline attribute */
  32 #ifndef SWIGINLINE
  33 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  34 #   define SWIGINLINE inline
  35 # else
  36 #   define SWIGINLINE
  37 # endif
  38 #endif
  39
  40 /* attribute recognised by some compilers to avoid 'unused' warnings */
  41 #ifndef SWIGUNUSED
  42 # if defined(__GNUC__)
  43 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  44 #     define SWIGUNUSED __attribute__ ((__unused__))
  45 #   else
  46 #     define SWIGUNUSED
  47 #   endif
  48 # elif defined(__ICC)
  49 #   define SWIGUNUSED __attribute__ ((__unused__))
  50 # else
  51 #   define SWIGUNUSED
  52 # endif
  53 #endif
  54
  55 #ifndef SWIGUNUSEDPARM
  56 # ifdef __cplusplus
  57 #   define SWIGUNUSEDPARM(p)
  58 # else
  59 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  60 # endif
  61 #endif
  62
  63 /* internal SWIG method */
  64 #ifndef SWIGINTERN
  65 # define SWIGINTERN static SWIGUNUSED
  66 #endif
  67
  68 /* internal inline SWIG method */
  69 #ifndef SWIGINTERNINLINE
  70 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  71 #endif
  72
  73 /* exporting methods */
  74 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  75 #  ifndef GCC_HASCLASSVISIBILITY
  76 #    define GCC_HASCLASSVISIBILITY
  77 #  endif
  78 #endif
  79
  80 #ifndef SWIGEXPORT
  81 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  82 #   if defined(STATIC_LINKED)
  83 #     define SWIGEXPORT
  84 #   else
  85 #     define SWIGEXPORT __declspec(dllexport)
  86 #   endif
  87 # else
  88 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
  89 #     define SWIGEXPORT __attribute__ ((visibility("default")))
  90 #   else
  91 #     define SWIGEXPORT
  92 #   endif
  93 # endif
  94 #endif
  95
  96 /* calling conventions for Windows */
  97 #ifndef SWIGSTDCALL
  98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  99 #   define SWIGSTDCALL __stdcall
 100 # else
 101 #   define SWIGSTDCALL
 102 # endif
 103 #endif
 104
 105 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 106 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 107 # define _CRT_SECURE_NO_DEPRECATE
 108 #endif
 109
 110 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 111 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 112 # define _SCL_SECURE_NO_DEPRECATE
 113 #endif
 114
 115
 116
 117 /* Python.h has to appear first */
 118 #include <Python.h>
 119
 120 /* -----------------------------------------------------------------------------
 121  * swigrun.swg
 122  *
 123  * This file contains generic CAPI SWIG runtime support for pointer
 124  * type checking.
 125  * ----------------------------------------------------------------------------- */
 126
 127 /* This should only be incremented when either the layout of swig_type_info changes,
 128    or for whatever reason, the runtime changes incompatibly */
 129 #define SWIG_RUNTIME_VERSION "3"
 130
 131 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 132 #ifdef SWIG_TYPE_TABLE
 133 # define SWIG_QUOTE_STRING(x) #x
 134 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 135 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 136 #else
 137 # define SWIG_TYPE_TABLE_NAME
 138 #endif
 139
 140 /*
 141   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 142   creating a static or dynamic library from the swig runtime code.
 143   In 99.9% of the cases, swig just needs to declare them as 'static'.
 144
 145   But only do this if is strictly necessary, ie, if you have problems
 146   with your compiler or so.
 147 */
 148
 149 #ifndef SWIGRUNTIME
 150 # define SWIGRUNTIME SWIGINTERN
 151 #endif
 152
 153 #ifndef SWIGRUNTIMEINLINE
 154 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 155 #endif
 156
 157 /*  Generic buffer size */
 158 #ifndef SWIG_BUFFER_SIZE
 159 # define SWIG_BUFFER_SIZE 1024
 160 #endif
 161
 162 /* Flags for pointer conversions */
 163 #define SWIG_POINTER_DISOWN        0x1
 164
 165 /* Flags for new pointer objects */
 166 #define SWIG_POINTER_OWN           0x1
 167
 168
 169 /*
 170    Flags/methods for returning states.
 171
 172    The swig conversion methods, as ConvertPtr, return and integer
 173    that tells if the conversion was successful or not. And if not,
 174    an error code can be returned (see swigerrors.swg for the codes).
 175
 176    Use the following macros/flags to set or process the returning
 177    states.
 178
 179    In old swig versions, you usually write code as:
 180
 181      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 182        // success code
 183      } else {
 184        //fail code
 185      }
 186
 187    Now you can be more explicit as:
 188
 189     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 190     if (SWIG_IsOK(res)) {
 191       // success code
 192     } else {
 193       // fail code
 194     }
 195
 196    that seems to be the same, but now you can also do
 197
 198     Type *ptr;
 199     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 200     if (SWIG_IsOK(res)) {
 201       // success code
 202       if (SWIG_IsNewObj(res) {
 203         ...
 204         delete *ptr;
 205       } else {
 206         ...
 207       }
 208     } else {
 209       // fail code
 210     }
 211
 212    I.e., now SWIG_ConvertPtr can return new objects and you can
 213    identify the case and take care of the deallocation. Of course that
 214    requires also to SWIG_ConvertPtr to return new result values, as
 215
 216       int SWIG_ConvertPtr(obj, ptr,...) {
 217         if (<obj is ok>) {
 218           if (<need new object>) {
 219             *ptr = <ptr to new allocated object>;
 220             return SWIG_NEWOBJ;
 221           } else {
 222             *ptr = <ptr to old object>;
 223             return SWIG_OLDOBJ;
 224           }
 225         } else {
 226           return SWIG_BADOBJ;
 227         }
 228       }
 229
 230    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 231    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 232    swig errors code.
 233
 234    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 235    allows to return the 'cast rank', for example, if you have this
 236
 237        int food(double)
 238        int fooi(int);
 239
 240    and you call
 241
 242       food(1)   // cast rank '1'  (1 -> 1.0)
 243       fooi(1)   // cast rank '0'
 244
 245    just use the SWIG_AddCast()/SWIG_CheckState()
 246
 247
 248  */
 249 #define SWIG_OK                    (0)
 250 #define SWIG_ERROR                 (-1)
 251 #define SWIG_IsOK(r)               (r >= 0)
 252 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 253
 254 /* The CastRankLimit says how many bits are used for the cast rank */
 255 #define SWIG_CASTRANKLIMIT         (1 << 8)
 256 /* The NewMask denotes the object was created (using new/malloc) */
 257 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 258 /* The TmpMask is for in/out typemaps that use temporal objects */
 259 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 260 /* Simple returning values */
 261 #define SWIG_BADOBJ                (SWIG_ERROR)
 262 #define SWIG_OLDOBJ                (SWIG_OK)
 263 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 264 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 265 /* Check, add and del mask methods */
 266 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 267 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 268 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 269 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 270 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 271 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 272
 273
 274 /* Cast-Rank Mode */
 275 #if defined(SWIG_CASTRANK_MODE)
 276 #  ifndef SWIG_TypeRank
 277 #    define SWIG_TypeRank             unsigned long
 278 #  endif
 279 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 280 #    define SWIG_MAXCASTRANK          (2)
 281 #  endif
 282 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 283 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 284 SWIGINTERNINLINE int SWIG_AddCast(int r) {
 285   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 286 }
 287 SWIGINTERNINLINE int SWIG_CheckState(int r) {
 288   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
 289 }
 290 #else /* no cast-rank mode */
 291 #  define SWIG_AddCast
 292 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 293 #endif
 294
 295
 296
 297
 298 #include <string.h>
 299
 300 #ifdef __cplusplus
 301 extern "C" {
 302 #endif
 303
 304 typedef void *(*swig_converter_func)(void *);
 305 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 306
 307 /* Structure to store inforomation on one type */
 308 typedef struct swig_type_info {
 309   const char             *name;                 /* mangled name of this type */
 310   const char             *str;                  /* human readable name of this type */
 311   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 312   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 313   void                   *clientdata;           /* language specific type data */
 314   int                    owndata;               /* flag if the structure owns the clientdata */
 315 } swig_type_info;
 316
 317 /* Structure to store a type and conversion function used for casting */
 318 typedef struct swig_cast_info {
 319   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 320   swig_converter_func     converter;            /* function to cast the void pointers */
 321   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 322   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 323 } swig_cast_info;
 324
 325 /* Structure used to store module information
 326  * Each module generates one structure like this, and the runtime collects
 327  * all of these structures and stores them in a circularly linked list.*/
 328 typedef struct swig_module_info {
 329   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 330   size_t                 size;                  /* Number of types in this module */
 331   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 332   swig_type_info         **type_initial;        /* Array of initially generated type structures */
 333   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 334   void                    *clientdata;          /* Language specific module data */
 335 } swig_module_info;
 336
 337 /*
 338   Compare two type names skipping the space characters, therefore
 339   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 340
 341   Return 0 when the two name types are equivalent, as in
 342   strncmp, but skipping ' '.
 343 */
 344 SWIGRUNTIME int
 345 SWIG_TypeNameComp(const char *f1, const char *l1,
 346                   const char *f2, const char *l2) {
 347   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 348     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 349     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 350     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 351   }
 352   return (int)((l1 - f1) - (l2 - f2));
 353 }
 354
 355 /*
 356   Check type equivalence in a name list like <name1>|<name2>|...
 357   Return 0 if not equal, 1 if equal
 358 */
 359 SWIGRUNTIME int
 360 SWIG_TypeEquiv(const char *nb, const char *tb) {
 361   int equiv = 0;
 362   const char* te = tb + strlen(tb);
 363   const char* ne = nb;
 364   while (!equiv && *ne) {
 365     for (nb = ne; *ne; ++ne) {
 366       if (*ne == '|') break;
 367     }
 368     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 369     if (*ne) ++ne;
 370   }
 371   return equiv;
 372 }
 373
 374 /*
 375   Check type equivalence in a name list like <name1>|<name2>|...
 376   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 377 */
 378 SWIGRUNTIME int
 379 SWIG_TypeCompare(const char *nb, const char *tb) {
 380   int equiv = 0;
 381   const char* te = tb + strlen(tb);
 382   const char* ne = nb;
 383   while (!equiv && *ne) {
 384     for (nb = ne; *ne; ++ne) {
 385       if (*ne == '|') break;
 386     }
 387     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 388     if (*ne) ++ne;
 389   }
 390   return equiv;
 391 }
 392
 393
 394 /* think of this as a c++ template<> or a scheme macro */
 395 #define SWIG_TypeCheck_Template(comparison, ty)         \
 396   if (ty) {                                             \
 397     swig_cast_info *iter = ty->cast;                    \
 398     while (iter) {                                      \
 399       if (comparison) {                                 \
 400         if (iter == ty->cast) return iter;              \
 401         /* Move iter to the top of the linked list */   \
 402         iter->prev->next = iter->next;                  \
 403         if (iter->next)                                 \
 404           iter->next->prev = iter->prev;                \
 405         iter->next = ty->cast;                          \
 406         iter->prev = 0;                                 \
 407         if (ty->cast) ty->cast->prev = iter;            \
 408         ty->cast = iter;                                \
 409         return iter;                                    \
 410       }                                                 \
 411       iter = iter->next;                                \
 412     }                                                   \
 413   }                                                     \
 414   return 0
 415
 416 /*
 417   Check the typename
 418 */
 419 SWIGRUNTIME swig_cast_info *
 420 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 421   SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 422 }
 423
 424 /* Same as previous function, except strcmp is replaced with a pointer comparison */
 425 SWIGRUNTIME swig_cast_info *
 426 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
 427   SWIG_TypeCheck_Template(iter->type == from, into);
 428 }
 429
 430 /*
 431   Cast a pointer up an inheritance hierarchy
 432 */
 433 SWIGRUNTIMEINLINE void *
 434 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
 435   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
 436 }
 437
 438 /*
 439    Dynamic pointer casting. Down an inheritance hierarchy
 440 */
 441 SWIGRUNTIME swig_type_info *
 442 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 443   swig_type_info *lastty = ty;
 444   if (!ty || !ty->dcast) return ty;
 445   while (ty && (ty->dcast)) {
 446     ty = (*ty->dcast)(ptr);
 447     if (ty) lastty = ty;
 448   }
 449   return lastty;
 450 }
 451
 452 /*
 453   Return the name associated with this type
 454 */
 455 SWIGRUNTIMEINLINE const char *
 456 SWIG_TypeName(const swig_type_info *ty) {
 457   return ty->name;
 458 }
 459
 460 /*
 461   Return the pretty name associated with this type,
 462   that is an unmangled type name in a form presentable to the user.
 463 */
 464 SWIGRUNTIME const char *
 465 SWIG_TypePrettyName(const swig_type_info *type) {
 466   /* The "str" field contains the equivalent pretty names of the
 467      type, separated by vertical-bar characters.  We choose
 468      to print the last name, as it is often (?) the most
 469      specific. */
 470   if (!type) return NULL;
 471   if (type->str != NULL) {
 472     const char *last_name = type->str;
 473     const char *s;
 474     for (s = type->str; *s; s++)
 475       if (*s == '|') last_name = s+1;
 476     return last_name;
 477   }
 478   else
 479     return type->name;
 480 }
 481
 482 /*
 483    Set the clientdata field for a type
 484 */
 485 SWIGRUNTIME void
 486 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 487   swig_cast_info *cast = ti->cast;
 488   /* if (ti->clientdata == clientdata) return; */
 489   ti->clientdata = clientdata;
 490
 491   while (cast) {
 492     if (!cast->converter) {
 493       swig_type_info *tc = cast->type;
 494       if (!tc->clientdata) {
 495         SWIG_TypeClientData(tc, clientdata);
 496       }
 497     }
 498     cast = cast->next;
 499   }
 500 }
 501 SWIGRUNTIME void
 502 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 503   SWIG_TypeClientData(ti, clientdata);
 504   ti->owndata = 1;
 505 }
 506
 507 /*
 508   Search for a swig_type_info structure only by mangled name
 509   Search is a O(log #types)
 510
 511   We start searching at module start, and finish searching when start == end.
 512   Note: if start == end at the beginning of the function, we go all the way around
 513   the circular list.
 514 */
 515 SWIGRUNTIME swig_type_info *
 516 SWIG_MangledTypeQueryModule(swig_module_info *start,
 517                             swig_module_info *end,
 518                             const char *name) {
 519   swig_module_info *iter = start;
 520   do {
 521     if (iter->size) {
 522       register size_t l = 0;
 523       register size_t r = iter->size - 1;
 524       do {
 525         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 526         register size_t i = (l + r) >> 1;
 527         const char *iname = iter->types[i]->name;
 528         if (iname) {
 529           register int compare = strcmp(name, iname);
 530           if (compare == 0) {
 531             return iter->types[i];
 532           } else if (compare < 0) {
 533             if (i) {
 534               r = i - 1;
 535             } else {
 536               break;
 537             }
 538           } else if (compare > 0) {
 539             l = i + 1;
 540           }
 541         } else {
 542           break; /* should never happen */
 543         }
 544       } while (l <= r);
 545     }
 546     iter = iter->next;
 547   } while (iter != end);
 548   return 0;
 549 }
 550
 551 /*
 552   Search for a swig_type_info structure for either a mangled name or a human readable name.
 553   It first searches the mangled names of the types, which is a O(log #types)
 554   If a type is not found it then searches the human readable names, which is O(#types).
 555
 556   We start searching at module start, and finish searching when start == end.
 557   Note: if start == end at the beginning of the function, we go all the way around
 558   the circular list.
 559 */
 560 SWIGRUNTIME swig_type_info *
 561 SWIG_TypeQueryModule(swig_module_info *start,
 562                      swig_module_info *end,
 563                      const char *name) {
 564   /* STEP 1: Search the name field using binary search */
 565   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 566   if (ret) {
 567     return ret;
 568   } else {
 569     /* STEP 2: If the type hasn't been found, do a complete search
 570        of the str field (the human readable name) */
 571     swig_module_info *iter = start;
 572     do {
 573       register size_t i = 0;
 574       for (; i < iter->size; ++i) {
 575         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 576           return iter->types[i];
 577       }
 578       iter = iter->next;
 579     } while (iter != end);
 580   }
 581
 582   /* neither found a match */
 583   return 0;
 584 }
 585
 586 /*
 587    Pack binary data into a string
 588 */
 589 SWIGRUNTIME char *
 590 SWIG_PackData(char *c, void *ptr, size_t sz) {
 591   static const char hex[17] = "0123456789abcdef";
 592   register const unsigned char *u = (unsigned char *) ptr;
 593   register const unsigned char *eu =  u + sz;
 594   for (; u != eu; ++u) {
 595     register unsigned char uu = *u;
 596     *(c++) = hex[(uu & 0xf0) >> 4];
 597     *(c++) = hex[uu & 0xf];
 598   }
 599   return c;
 600 }
 601
 602 /*
 603    Unpack binary data from a string
 604 */
 605 SWIGRUNTIME const char *
 606 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 607   register unsigned char *u = (unsigned char *) ptr;
 608   register const unsigned char *eu = u + sz;
 609   for (; u != eu; ++u) {
 610     register char d = *(c++);
 611     register unsigned char uu;
 612     if ((d >= '0') && (d <= '9'))
 613       uu = ((d - '0') << 4);
 614     else if ((d >= 'a') && (d <= 'f'))
 615       uu = ((d - ('a'-10)) << 4);
 616     else
 617       return (char *) 0;
 618     d = *(c++);
 619     if ((d >= '0') && (d <= '9'))
 620       uu |= (d - '0');
 621     else if ((d >= 'a') && (d <= 'f'))
 622       uu |= (d - ('a'-10));
 623     else
 624       return (char *) 0;
 625     *u = uu;
 626   }
 627   return c;
 628 }
 629
 630 /*
 631    Pack 'void *' into a string buffer.
 632 */
 633 SWIGRUNTIME char *
 634 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 635   char *r = buff;
 636   if ((2*sizeof(void *) + 2) > bsz) return 0;
 637   *(r++) = '_';
 638   r = SWIG_PackData(r,&ptr,sizeof(void *));
 639   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 640   strcpy(r,name);
 641   return buff;
 642 }
 643
 644 SWIGRUNTIME const char *
 645 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 646   if (*c != '_') {
 647     if (strcmp(c,"NULL") == 0) {
 648       *ptr = (void *) 0;
 649       return name;
 650     } else {
 651       return 0;
 652     }
 653   }
 654   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 655 }
 656
 657 SWIGRUNTIME char *
 658 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 659   char *r = buff;
 660   size_t lname = (name ? strlen(name) : 0);
 661   if ((2*sz + 2 + lname) > bsz) return 0;
 662   *(r++) = '_';
 663   r = SWIG_PackData(r,ptr,sz);
 664   if (lname) {
 665     strncpy(r,name,lname+1);
 666   } else {
 667     *r = 0;
 668   }
 669   return buff;
 670 }
 671
 672 SWIGRUNTIME const char *
 673 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 674   if (*c != '_') {
 675     if (strcmp(c,"NULL") == 0) {
 676       memset(ptr,0,sz);
 677       return name;
 678     } else {
 679       return 0;
 680     }
 681   }
 682   return SWIG_UnpackData(++c,ptr,sz);
 683 }
 684
 685 #ifdef __cplusplus
 686 }
 687 #endif
 688
 689 /*  Errors in SWIG */
 690 #define  SWIG_UnknownError         -1
 691 #define  SWIG_IOError              -2
 692 #define  SWIG_RuntimeError         -3
 693 #define  SWIG_IndexError           -4
 694 #define  SWIG_TypeError            -5
 695 #define  SWIG_DivisionByZero       -6
 696 #define  SWIG_OverflowError        -7
 697 #define  SWIG_SyntaxError          -8
 698 #define  SWIG_ValueError           -9
 699 #define  SWIG_SystemError          -10
 700 #define  SWIG_AttributeError       -11
 701 #define  SWIG_MemoryError          -12
 702 #define  SWIG_NullReferenceError   -13
 703
 704
 705
 706
 707 /* Add PyOS_snprintf for old Pythons */
 708 #if PY_VERSION_HEX < 0x02020000
 709 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
 710 #  define PyOS_snprintf _snprintf
 711 # else
 712 #  define PyOS_snprintf snprintf
 713 # endif
 714 #endif
 715
 716 /* A crude PyString_FromFormat implementation for old Pythons */
 717 #if PY_VERSION_HEX < 0x02020000
 718
 719 #ifndef SWIG_PYBUFFER_SIZE
 720 # define SWIG_PYBUFFER_SIZE 1024
 721 #endif
 722
 723 static PyObject *
 724 PyString_FromFormat(const char *fmt, ...) {
 725   va_list ap;
 726   char buf[SWIG_PYBUFFER_SIZE * 2];
 727   int res;
 728   va_start(ap, fmt);
 729   res = vsnprintf(buf, sizeof(buf), fmt, ap);
 730   va_end(ap);
 731   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
 732 }
 733 #endif
 734
 735 /* Add PyObject_Del for old Pythons */
 736 #if PY_VERSION_HEX < 0x01060000
 737 # define PyObject_Del(op) PyMem_DEL((op))
 738 #endif
 739 #ifndef PyObject_DEL
 740 # define PyObject_DEL PyObject_Del
 741 #endif
 742
 743 /* A crude PyExc_StopIteration exception for old Pythons */
 744 #if PY_VERSION_HEX < 0x02020000
 745 # ifndef PyExc_StopIteration
 746 #  define PyExc_StopIteration PyExc_RuntimeError
 747 # endif
 748 # ifndef PyObject_GenericGetAttr
 749 #  define PyObject_GenericGetAttr 0
 750 # endif
 751 #endif
 752 /* Py_NotImplemented is defined in 2.1 and up. */
 753 #if PY_VERSION_HEX < 0x02010000
 754 # ifndef Py_NotImplemented
 755 #  define Py_NotImplemented PyExc_RuntimeError
 756 # endif
 757 #endif
 758
 759
 760 /* A crude PyString_AsStringAndSize implementation for old Pythons */
 761 #if PY_VERSION_HEX < 0x02010000
 762 # ifndef PyString_AsStringAndSize
 763 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
 764 # endif
 765 #endif
 766
 767 /* PySequence_Size for old Pythons */
 768 #if PY_VERSION_HEX < 0x02000000
 769 # ifndef PySequence_Size
 770 #  define PySequence_Size PySequence_Length
 771 # endif
 772 #endif
 773
 774
 775 /* PyBool_FromLong for old Pythons */
 776 #if PY_VERSION_HEX < 0x02030000
 777 static
 778 PyObject *PyBool_FromLong(long ok)
 779 {
 780   PyObject *result = ok ? Py_True : Py_False;
 781   Py_INCREF(result);
 782   return result;
 783 }
 784 #endif
 785
 786 /* Py_ssize_t for old Pythons */
 787 /* This code is as recommended by: */
 788 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
 789 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
 790 typedef int Py_ssize_t;
 791 # define PY_SSIZE_T_MAX INT_MAX
 792 # define PY_SSIZE_T_MIN INT_MIN
 793 #endif
 794
 795 /* -----------------------------------------------------------------------------
 796  * error manipulation
 797  * ----------------------------------------------------------------------------- */
 798
 799 SWIGRUNTIME PyObject*
 800 SWIG_Python_ErrorType(int code) {
 801   PyObject* type = 0;
 802   switch(code) {
 803   case SWIG_MemoryError:
 804     type = PyExc_MemoryError;
 805     break;
 806   case SWIG_IOError:
 807     type = PyExc_IOError;
 808     break;
 809   case SWIG_RuntimeError:
 810     type = PyExc_RuntimeError;
 811     break;
 812   case SWIG_IndexError:
 813     type = PyExc_IndexError;
 814     break;
 815   case SWIG_TypeError:
 816     type = PyExc_TypeError;
 817     break;
 818   case SWIG_DivisionByZero:
 819     type = PyExc_ZeroDivisionError;
 820     break;
 821   case SWIG_OverflowError:
 822     type = PyExc_OverflowError;
 823     break;
 824   case SWIG_SyntaxError:
 825     type = PyExc_SyntaxError;
 826     break;
 827   case SWIG_ValueError:
 828     type = PyExc_ValueError;
 829     break;
 830   case SWIG_SystemError:
 831     type = PyExc_SystemError;
 832     break;
 833   case SWIG_AttributeError:
 834     type = PyExc_AttributeError;
 835     break;
 836   default:
 837     type = PyExc_RuntimeError;
 838   }
 839   return type;
 840 }
 841
 842
 843 SWIGRUNTIME void
 844 SWIG_Python_AddErrorMsg(const char* mesg)
 845 {
 846   PyObject *type = 0;
 847   PyObject *value = 0;
 848   PyObject *traceback = 0;
 849
 850   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
 851   if (value) {
 852     PyObject *old_str = PyObject_Str(value);
 853     PyErr_Clear();
 854     Py_XINCREF(type);
 855     PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
 856     Py_DECREF(old_str);
 857     Py_DECREF(value);
 858   } else {
 859     PyErr_Format(PyExc_RuntimeError, mesg);
 860   }
 861 }
 862
 863
 864
 865 #if defined(SWIG_PYTHON_NO_THREADS)
 866 #  if defined(SWIG_PYTHON_THREADS)
 867 #    undef SWIG_PYTHON_THREADS
 868 #  endif
 869 #endif
 870 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
 871 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
 872 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
 873 #      define SWIG_PYTHON_USE_GIL
 874 #    endif
 875 #  endif
 876 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
 877 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
 878 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads()
 879 #    endif
 880 #    ifdef __cplusplus /* C++ code */
 881        class SWIG_Python_Thread_Block {
 882          bool status;
 883          PyGILState_STATE state;
 884        public:
 885          void end() { if (status) { PyGILState_Release(state); status = false;} }
 886          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
 887          ~SWIG_Python_Thread_Block() { end(); }
 888        };
 889        class SWIG_Python_Thread_Allow {
 890          bool status;
 891          PyThreadState *save;
 892        public:
 893          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
 894          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
 895          ~SWIG_Python_Thread_Allow() { end(); }
 896        };
 897 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
 898 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
 899 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
 900 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
 901 #    else /* C code */
 902 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
 903 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
 904 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
 905 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
 906 #    endif
 907 #  else /* Old thread way, not implemented, user must provide it */
 908 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
 909 #      define SWIG_PYTHON_INITIALIZE_THREADS
 910 #    endif
 911 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
 912 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 913 #    endif
 914 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
 915 #      define SWIG_PYTHON_THREAD_END_BLOCK
 916 #    endif
 917 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
 918 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 919 #    endif
 920 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
 921 #      define SWIG_PYTHON_THREAD_END_ALLOW
 922 #    endif
 923 #  endif
 924 #else /* No thread support */
 925 #  define SWIG_PYTHON_INITIALIZE_THREADS
 926 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 927 #  define SWIG_PYTHON_THREAD_END_BLOCK
 928 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 929 #  define SWIG_PYTHON_THREAD_END_ALLOW
 930 #endif
 931
 932 /* -----------------------------------------------------------------------------
 933  * Python API portion that goes into the runtime
 934  * ----------------------------------------------------------------------------- */
 935
 936 #ifdef __cplusplus
 937 extern "C" {
 938 #if 0
 939 } /* cc-mode */
 940 #endif
 941 #endif
 942
 943 /* -----------------------------------------------------------------------------
 944  * Constant declarations
 945  * ----------------------------------------------------------------------------- */
 946
 947 /* Constant Types */
 948 #define SWIG_PY_POINTER 4
 949 #define SWIG_PY_BINARY  5
 950
 951 /* Constant information structure */
 952 typedef struct swig_const_info {
 953   int type;
 954   char *name;
 955   long lvalue;
 956   double dvalue;
 957   void   *pvalue;
 958   swig_type_info **ptype;
 959 } swig_const_info;
 960
 961 #ifdef __cplusplus
 962 #if 0
 963 { /* cc-mode */
 964 #endif
 965 }
 966 #endif
 967
 968
 969 /* -----------------------------------------------------------------------------
 970  * See the LICENSE file for information on copyright, usage and redistribution
 971  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 972  *
 973  * pyrun.swg
 974  *
 975  * This file contains the runtime support for Python modules
 976  * and includes code for managing global variables and pointer
 977  * type checking.
 978  *
 979  * ----------------------------------------------------------------------------- */
 980
 981 /* Common SWIG API */
 982
 983 /* for raw pointers */
 984 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
 985 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
 986 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
 987 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
 988 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty)
 989 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
 990 #define swig_owntype                                    int
 991
 992 /* for raw packed data */
 993 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
 994 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
 995
 996 /* for class or struct pointers */
 997 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
 998 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
 999
1000 /* for C or C++ function pointers */
1001 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1002 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
1003
1004 /* for C++ member pointers, ie, member methods */
1005 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1006 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1007
1008
1009 /* Runtime API */
1010
1011 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1012 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1013 #define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
1014
1015 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
1016 #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg
1017 #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)
1018 #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1019 #define SWIG_fail                                       goto fail
1020
1021
1022 /* Runtime API implementation */
1023
1024 /* Error manipulation */
1025
1026 SWIGINTERN void
1027 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1028   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1029   PyErr_SetObject(errtype, obj);
1030   Py_DECREF(obj);
1031   SWIG_PYTHON_THREAD_END_BLOCK;
1032 }
1033
1034 SWIGINTERN void
1035 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1036   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1037   PyErr_SetString(errtype, (char *) msg);
1038   SWIG_PYTHON_THREAD_END_BLOCK;
1039 }
1040
1041 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1042
1043 /* Set a constant value */
1044
1045 SWIGINTERN void
1046 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1047   PyDict_SetItemString(d, (char*) name, obj);
1048   Py_DECREF(obj);
1049 }
1050
1051 /* Append a value to the result obj */
1052
1053 SWIGINTERN PyObject*
1054 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1055 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1056   if (!result) {
1057     result = obj;
1058   } else if (result == Py_None) {
1059     Py_DECREF(result);
1060     result = obj;
1061   } else {
1062     if (!PyList_Check(result)) {
1063       PyObject *o2 = result;
1064       result = PyList_New(1);
1065       PyList_SetItem(result, 0, o2);
1066     }
1067     PyList_Append(result,obj);
1068     Py_DECREF(obj);
1069   }
1070   return result;
1071 #else
1072   PyObject*   o2;
1073   PyObject*   o3;
1074   if (!result) {
1075     result = obj;
1076   } else if (result == Py_None) {
1077     Py_DECREF(result);
1078     result = obj;
1079   } else {
1080     if (!PyTuple_Check(result)) {
1081       o2 = result;
1082       result = PyTuple_New(1);
1083       PyTuple_SET_ITEM(result, 0, o2);
1084     }
1085     o3 = PyTuple_New(1);
1086     PyTuple_SET_ITEM(o3, 0, obj);
1087     o2 = result;
1088     result = PySequence_Concat(o2, o3);
1089     Py_DECREF(o2);
1090     Py_DECREF(o3);
1091   }
1092   return result;
1093 #endif
1094 }
1095
1096 /* Unpack the argument tuple */
1097
1098 SWIGINTERN int
1099 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1100 {
1101   if (!args) {
1102     if (!min && !max) {
1103       return 1;
1104     } else {
1105       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1106                    name, (min == max ? "" : "at least "), (int)min);
1107       return 0;
1108     }
1109   }
1110   if (!PyTuple_Check(args)) {
1111     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1112     return 0;
1113   } else {
1114     register Py_ssize_t l = PyTuple_GET_SIZE(args);
1115     if (l < min) {
1116       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1117                    name, (min == max ? "" : "at least "), (int)min, (int)l);
1118       return 0;
1119     } else if (l > max) {
1120       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1121                    name, (min == max ? "" : "at most "), (int)max, (int)l);
1122       return 0;
1123     } else {
1124       register int i;
1125       for (i = 0; i < l; ++i) {
1126         objs[i] = PyTuple_GET_ITEM(args, i);
1127       }
1128       for (; l < max; ++l) {
1129         objs[l] = 0;
1130       }
1131       return i + 1;
1132     }
1133   }
1134 }
1135
1136 /* A functor is a function object with one single object argument */
1137 #if PY_VERSION_HEX >= 0x02020000
1138 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
1139 #else
1140 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
1141 #endif
1142
1143 /*
1144   Helper for static pointer initialization for both C and C++ code, for example
1145   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1146 */
1147 #ifdef __cplusplus
1148 #define SWIG_STATIC_POINTER(var)  var
1149 #else
1150 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1151 #endif
1152
1153 /* -----------------------------------------------------------------------------
1154  * Pointer declarations
1155  * ----------------------------------------------------------------------------- */
1156
1157 /* Flags for new pointer objects */
1158 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
1159 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1160
1161 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1162
1163 #ifdef __cplusplus
1164 extern "C" {
1165 #if 0
1166 } /* cc-mode */
1167 #endif
1168 #endif
1169
1170 /*  How to access Py_None */
1171 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1172 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
1173 #    ifndef SWIG_PYTHON_BUILD_NONE
1174 #      define SWIG_PYTHON_BUILD_NONE
1175 #    endif
1176 #  endif
1177 #endif
1178
1179 #ifdef SWIG_PYTHON_BUILD_NONE
1180 #  ifdef Py_None
1181 #   undef Py_None
1182 #   define Py_None SWIG_Py_None()
1183 #  endif
1184 SWIGRUNTIMEINLINE PyObject *
1185 _SWIG_Py_None(void)
1186 {
1187   PyObject *none = Py_BuildValue((char*)"");
1188   Py_DECREF(none);
1189   return none;
1190 }
1191 SWIGRUNTIME PyObject *
1192 SWIG_Py_None(void)
1193 {
1194   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1195   return none;
1196 }
1197 #endif
1198
1199 /* The python void return value */
1200
1201 SWIGRUNTIMEINLINE PyObject *
1202 SWIG_Py_Void(void)
1203 {
1204   PyObject *none = Py_None;
1205   Py_INCREF(none);
1206   return none;
1207 }
1208
1209 /* PySwigClientData */
1210
1211 typedef struct {
1212   PyObject *klass;
1213   PyObject *newraw;
1214   PyObject *newargs;
1215   PyObject *destroy;
1216   int delargs;
1217   int implicitconv;
1218 } PySwigClientData;
1219
1220 SWIGRUNTIMEINLINE int
1221 SWIG_Python_CheckImplicit(swig_type_info *ty)
1222 {
1223   PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1224   return data ? data->implicitconv : 0;
1225 }
1226
1227 SWIGRUNTIMEINLINE PyObject *
1228 SWIG_Python_ExceptionType(swig_type_info *desc) {
1229   PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1230   PyObject *klass = data ? data->klass : 0;
1231   return (klass ? klass : PyExc_RuntimeError);
1232 }
1233
1234
1235 SWIGRUNTIME PySwigClientData *
1236 PySwigClientData_New(PyObject* obj)
1237 {
1238   if (!obj) {
1239     return 0;
1240   } else {
1241     PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1242     /* the klass element */
1243     data->klass = obj;
1244     Py_INCREF(data->klass);
1245     /* the newraw method and newargs arguments used to create a new raw instance */
1246     if (PyClass_Check(obj)) {
1247       data->newraw = 0;
1248       data->newargs = obj;
1249       Py_INCREF(obj);
1250     } else {
1251 #if (PY_VERSION_HEX < 0x02020000)
1252       data->newraw = 0;
1253 #else
1254       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1255 #endif
1256       if (data->newraw) {
1257         Py_INCREF(data->newraw);
1258         data->newargs = PyTuple_New(1);
1259         PyTuple_SetItem(data->newargs, 0, obj);
1260       } else {
1261         data->newargs = obj;
1262       }
1263       Py_INCREF(data->newargs);
1264     }
1265     /* the destroy method, aka as the C++ delete method */
1266     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1267     if (PyErr_Occurred()) {
1268       PyErr_Clear();
1269       data->destroy = 0;
1270     }
1271     if (data->destroy) {
1272       int flags;
1273       Py_INCREF(data->destroy);
1274       flags = PyCFunction_GET_FLAGS(data->destroy);
1275 #ifdef METH_O
1276       data->delargs = !(flags & (METH_O));
1277 #else
1278       data->delargs = 0;
1279 #endif
1280     } else {
1281       data->delargs = 0;
1282     }
1283     data->implicitconv = 0;
1284     return data;
1285   }
1286 }
1287
1288 SWIGRUNTIME void
1289 PySwigClientData_Del(PySwigClientData* data)
1290 {
1291   Py_XDECREF(data->newraw);
1292   Py_XDECREF(data->newargs);
1293   Py_XDECREF(data->destroy);
1294 }
1295
1296 /* =============== PySwigObject =====================*/
1297
1298 typedef struct {
1299   PyObject_HEAD
1300   void *ptr;
1301   swig_type_info *ty;
1302   int own;
1303   PyObject *next;
1304 } PySwigObject;
1305
1306 SWIGRUNTIME PyObject *
1307 PySwigObject_long(PySwigObject *v)
1308 {
1309   return PyLong_FromVoidPtr(v->ptr);
1310 }
1311
1312 SWIGRUNTIME PyObject *
1313 PySwigObject_format(const char* fmt, PySwigObject *v)
1314 {
1315   PyObject *res = NULL;
1316   PyObject *args = PyTuple_New(1);
1317   if (args) {
1318     if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1319       PyObject *ofmt = PyString_FromString(fmt);
1320       if (ofmt) {
1321         res = PyString_Format(ofmt,args);
1322         Py_DECREF(ofmt);
1323       }
1324       Py_DECREF(args);
1325     }
1326   }
1327   return res;
1328 }
1329
1330 SWIGRUNTIME PyObject *
1331 PySwigObject_oct(PySwigObject *v)
1332 {
1333   return PySwigObject_format("%o",v);
1334 }
1335
1336 SWIGRUNTIME PyObject *
1337 PySwigObject_hex(PySwigObject *v)
1338 {
1339   return PySwigObject_format("%x",v);
1340 }
1341
1342 SWIGRUNTIME PyObject *
1343 #ifdef METH_NOARGS
1344 PySwigObject_repr(PySwigObject *v)
1345 #else
1346 PySwigObject_repr(PySwigObject *v, PyObject *args)
1347 #endif
1348 {
1349   const char *name = SWIG_TypePrettyName(v->ty);
1350   PyObject *hex = PySwigObject_hex(v);
1351   PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1352   Py_DECREF(hex);
1353   if (v->next) {
1354 #ifdef METH_NOARGS
1355     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1356 #else
1357     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1358 #endif
1359     PyString_ConcatAndDel(&repr,nrep);
1360   }
1361   return repr;
1362 }
1363
1364 SWIGRUNTIME int
1365 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1366 {
1367 #ifdef METH_NOARGS
1368   PyObject *repr = PySwigObject_repr(v);
1369 #else
1370   PyObject *repr = PySwigObject_repr(v, NULL);
1371 #endif
1372   if (repr) {
1373     fputs(PyString_AsString(repr), fp);
1374     Py_DECREF(repr);
1375     return 0;
1376   } else {
1377     return 1;
1378   }
1379 }
1380
1381 SWIGRUNTIME PyObject *
1382 PySwigObject_str(PySwigObject *v)
1383 {
1384   char result[SWIG_BUFFER_SIZE];
1385   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1386     PyString_FromString(result) : 0;
1387 }
1388
1389 SWIGRUNTIME int
1390 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1391 {
1392   void *i = v->ptr;
1393   void *j = w->ptr;
1394   return (i < j) ? -1 : ((i > j) ? 1 : 0);
1395 }
1396
1397 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1398
1399 SWIGRUNTIME PyTypeObject*
1400 PySwigObject_type(void) {
1401   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1402   return type;
1403 }
1404
1405 SWIGRUNTIMEINLINE int
1406 PySwigObject_Check(PyObject *op) {
1407   return ((op)->ob_type == PySwigObject_type())
1408     || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1409 }
1410
1411 SWIGRUNTIME PyObject *
1412 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1413
1414 SWIGRUNTIME void
1415 PySwigObject_dealloc(PyObject *v)
1416 {
1417   PySwigObject *sobj = (PySwigObject *) v;
1418   PyObject *next = sobj->next;
1419   if (sobj->own) {
1420     swig_type_info *ty = sobj->ty;
1421     PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1422     PyObject *destroy = data ? data->destroy : 0;
1423     if (destroy) {
1424       /* destroy is always a VARARGS method */
1425       PyObject *res;
1426       if (data->delargs) {
1427         /* we need to create a temporal object to carry the destroy operation */
1428         PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1429         res = SWIG_Python_CallFunctor(destroy, tmp);
1430         Py_DECREF(tmp);
1431       } else {
1432         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1433         PyObject *mself = PyCFunction_GET_SELF(destroy);
1434         res = ((*meth)(mself, v));
1435       }
1436       Py_XDECREF(res);
1437     } else {
1438       const char *name = SWIG_TypePrettyName(ty);
1439 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1440       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1441 #endif
1442     }
1443   }
1444   Py_XDECREF(next);
1445   PyObject_DEL(v);
1446 }
1447
1448 SWIGRUNTIME PyObject*
1449 PySwigObject_append(PyObject* v, PyObject* next)
1450 {
1451   PySwigObject *sobj = (PySwigObject *) v;
1452 #ifndef METH_O
1453   PyObject *tmp = 0;
1454   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1455   next = tmp;
1456 #endif
1457   if (!PySwigObject_Check(next)) {
1458     return NULL;
1459   }
1460   sobj->next = next;
1461   Py_INCREF(next);
1462   return SWIG_Py_Void();
1463 }
1464
1465 SWIGRUNTIME PyObject*
1466 #ifdef METH_NOARGS
1467 PySwigObject_next(PyObject* v)
1468 #else
1469 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1470 #endif
1471 {
1472   PySwigObject *sobj = (PySwigObject *) v;
1473   if (sobj->next) {
1474     Py_INCREF(sobj->next);
1475     return sobj->next;
1476   } else {
1477     return SWIG_Py_Void();
1478   }
1479 }
1480
1481 SWIGINTERN PyObject*
1482 #ifdef METH_NOARGS
1483 PySwigObject_disown(PyObject *v)
1484 #else
1485 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1486 #endif
1487 {
1488   PySwigObject *sobj = (PySwigObject *)v;
1489   sobj->own = 0;
1490   return SWIG_Py_Void();
1491 }
1492
1493 SWIGINTERN PyObject*
1494 #ifdef METH_NOARGS
1495 PySwigObject_acquire(PyObject *v)
1496 #else
1497 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1498 #endif
1499 {
1500   PySwigObject *sobj = (PySwigObject *)v;
1501   sobj->own = SWIG_POINTER_OWN;
1502   return SWIG_Py_Void();
1503 }
1504
1505 SWIGINTERN PyObject*
1506 PySwigObject_own(PyObject *v, PyObject *args)
1507 {
1508   PyObject *val = 0;
1509 #if (PY_VERSION_HEX < 0x02020000)
1510   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1511 #else
1512   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1513 #endif
1514     {
1515       return NULL;
1516     }
1517   else
1518     {
1519       PySwigObject *sobj = (PySwigObject *)v;
1520       PyObject *obj = PyBool_FromLong(sobj->own);
1521       if (val) {
1522 #ifdef METH_NOARGS
1523         if (PyObject_IsTrue(val)) {
1524           PySwigObject_acquire(v);
1525         } else {
1526           PySwigObject_disown(v);
1527         }
1528 #else
1529         if (PyObject_IsTrue(val)) {
1530           PySwigObject_acquire(v,args);
1531         } else {
1532           PySwigObject_disown(v,args);
1533         }
1534 #endif
1535       }
1536       return obj;
1537     }
1538 }
1539
1540 #ifdef METH_O
1541 static PyMethodDef
1542 swigobject_methods[] = {
1543   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1544   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
1545   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1546   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
1547   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1548   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1549   {0, 0, 0, 0}
1550 };
1551 #else
1552 static PyMethodDef
1553 swigobject_methods[] = {
1554   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1555   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1556   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1557   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1558   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1559   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1560   {0, 0, 0, 0}
1561 };
1562 #endif
1563
1564 #if PY_VERSION_HEX < 0x02020000
1565 SWIGINTERN PyObject *
1566 PySwigObject_getattr(PySwigObject *sobj,char *name)
1567 {
1568   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1569 }
1570 #endif
1571
1572 SWIGRUNTIME PyTypeObject*
1573 _PySwigObject_type(void) {
1574   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1575
1576   static PyNumberMethods PySwigObject_as_number = {
1577     (binaryfunc)0, /*nb_add*/
1578     (binaryfunc)0, /*nb_subtract*/
1579     (binaryfunc)0, /*nb_multiply*/
1580     (binaryfunc)0, /*nb_divide*/
1581     (binaryfunc)0, /*nb_remainder*/
1582     (binaryfunc)0, /*nb_divmod*/
1583     (ternaryfunc)0,/*nb_power*/
1584     (unaryfunc)0,  /*nb_negative*/
1585     (unaryfunc)0,  /*nb_positive*/
1586     (unaryfunc)0,  /*nb_absolute*/
1587     (inquiry)0,    /*nb_nonzero*/
1588     0,             /*nb_invert*/
1589     0,             /*nb_lshift*/
1590     0,             /*nb_rshift*/
1591     0,             /*nb_and*/
1592     0,             /*nb_xor*/
1593     0,             /*nb_or*/
1594     (coercion)0,   /*nb_coerce*/
1595     (unaryfunc)PySwigObject_long, /*nb_int*/
1596     (unaryfunc)PySwigObject_long, /*nb_long*/
1597     (unaryfunc)0,                 /*nb_float*/
1598     (unaryfunc)PySwigObject_oct,  /*nb_oct*/
1599     (unaryfunc)PySwigObject_hex,  /*nb_hex*/
1600 #if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1601     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1602 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1603     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1604 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1605     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1606 #endif
1607   };
1608
1609   static PyTypeObject pyswigobject_type;
1610   static int type_init = 0;
1611   if (!type_init) {
1612     const PyTypeObject tmp
1613       = {
1614         PyObject_HEAD_INIT(NULL)
1615         0,                                  /* ob_size */
1616         (char *)"PySwigObject",             /* tp_name */
1617         sizeof(PySwigObject),               /* tp_basicsize */
1618         0,                                  /* tp_itemsize */
1619         (destructor)PySwigObject_dealloc,   /* tp_dealloc */
1620         (printfunc)PySwigObject_print,      /* tp_print */
1621 #if PY_VERSION_HEX < 0x02020000
1622         (getattrfunc)PySwigObject_getattr,  /* tp_getattr */
1623 #else
1624         (getattrfunc)0,                     /* tp_getattr */
1625 #endif
1626         (setattrfunc)0,                     /* tp_setattr */
1627         (cmpfunc)PySwigObject_compare,      /* tp_compare */
1628         (reprfunc)PySwigObject_repr,        /* tp_repr */
1629         &PySwigObject_as_number,            /* tp_as_number */
1630         0,                                  /* tp_as_sequence */
1631         0,                                  /* tp_as_mapping */
1632         (hashfunc)0,                        /* tp_hash */
1633         (ternaryfunc)0,                     /* tp_call */
1634         (reprfunc)PySwigObject_str,         /* tp_str */
1635         PyObject_GenericGetAttr,            /* tp_getattro */
1636         0,                                  /* tp_setattro */
1637         0,                                  /* tp_as_buffer */
1638         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1639         swigobject_doc,                     /* tp_doc */
1640         0,                                  /* tp_traverse */
1641         0,                                  /* tp_clear */
1642         0,                                  /* tp_richcompare */
1643         0,                                  /* tp_weaklistoffset */
1644 #if PY_VERSION_HEX >= 0x02020000
1645         0,                                  /* tp_iter */
1646         0,                                  /* tp_iternext */
1647         swigobject_methods,                 /* tp_methods */
1648         0,                                  /* tp_members */
1649         0,                                  /* tp_getset */
1650         0,                                  /* tp_base */
1651         0,                                  /* tp_dict */
1652         0,                                  /* tp_descr_get */
1653         0,                                  /* tp_descr_set */
1654         0,                                  /* tp_dictoffset */
1655         0,                                  /* tp_init */
1656         0,                                  /* tp_alloc */
1657         0,                                  /* tp_new */
1658         0,                                  /* tp_free */
1659         0,                                  /* tp_is_gc */
1660         0,                                  /* tp_bases */
1661         0,                                  /* tp_mro */
1662         0,                                  /* tp_cache */
1663         0,                                  /* tp_subclasses */
1664         0,                                  /* tp_weaklist */
1665 #endif
1666 #if PY_VERSION_HEX >= 0x02030000
1667         0,                                  /* tp_del */
1668 #endif
1669 #ifdef COUNT_ALLOCS
1670         0,0,0,0                             /* tp_alloc -> tp_next */
1671 #endif
1672       };
1673     pyswigobject_type = tmp;
1674     pyswigobject_type.ob_type = &PyType_Type;
1675     type_init = 1;
1676   }
1677   return &pyswigobject_type;
1678 }
1679
1680 SWIGRUNTIME PyObject *
1681 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1682 {
1683   PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1684   if (sobj) {
1685     sobj->ptr  = ptr;
1686     sobj->ty   = ty;
1687     sobj->own  = own;
1688     sobj->next = 0;
1689   }
1690   return (PyObject *)sobj;
1691 }
1692
1693 /* -----------------------------------------------------------------------------
1694  * Implements a simple Swig Packed type, and use it instead of string
1695  * ----------------------------------------------------------------------------- */
1696
1697 typedef struct {
1698   PyObject_HEAD
1699   void *pack;
1700   swig_type_info *ty;
1701   size_t size;
1702 } PySwigPacked;
1703
1704 SWIGRUNTIME int
1705 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1706 {
1707   char result[SWIG_BUFFER_SIZE];
1708   fputs("<Swig Packed ", fp);
1709   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1710     fputs("at ", fp);
1711     fputs(result, fp);
1712   }
1713   fputs(v->ty->name,fp);
1714   fputs(">", fp);
1715   return 0;
1716 }
1717
1718 SWIGRUNTIME PyObject *
1719 PySwigPacked_repr(PySwigPacked *v)
1720 {
1721   char result[SWIG_BUFFER_SIZE];
1722   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1723     return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1724   } else {
1725     return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1726   }
1727 }
1728
1729 SWIGRUNTIME PyObject *
1730 PySwigPacked_str(PySwigPacked *v)
1731 {
1732   char result[SWIG_BUFFER_SIZE];
1733   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1734     return PyString_FromFormat("%s%s", result, v->ty->name);
1735   } else {
1736     return PyString_FromString(v->ty->name);
1737   }
1738 }
1739
1740 SWIGRUNTIME int
1741 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1742 {
1743   size_t i = v->size;
1744   size_t j = w->size;
1745   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1746   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1747 }
1748
1749 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1750
1751 SWIGRUNTIME PyTypeObject*
1752 PySwigPacked_type(void) {
1753   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1754   return type;
1755 }
1756
1757 SWIGRUNTIMEINLINE int
1758 PySwigPacked_Check(PyObject *op) {
1759   return ((op)->ob_type == _PySwigPacked_type())
1760     || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1761 }
1762
1763 SWIGRUNTIME void
1764 PySwigPacked_dealloc(PyObject *v)
1765 {
1766   if (PySwigPacked_Check(v)) {
1767     PySwigPacked *sobj = (PySwigPacked *) v;
1768     free(sobj->pack);
1769   }
1770   PyObject_DEL(v);
1771 }
1772
1773 SWIGRUNTIME PyTypeObject*
1774 _PySwigPacked_type(void) {
1775   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1776   static PyTypeObject pyswigpacked_type;
1777   static int type_init = 0;
1778   if (!type_init) {
1779     const PyTypeObject tmp
1780       = {
1781         PyObject_HEAD_INIT(NULL)
1782         0,                                  /* ob_size */
1783         (char *)"PySwigPacked",             /* tp_name */
1784         sizeof(PySwigPacked),               /* tp_basicsize */
1785         0,                                  /* tp_itemsize */
1786         (destructor)PySwigPacked_dealloc,   /* tp_dealloc */
1787         (printfunc)PySwigPacked_print,      /* tp_print */
1788         (getattrfunc)0,                     /* tp_getattr */
1789         (setattrfunc)0,                     /* tp_setattr */
1790         (cmpfunc)PySwigPacked_compare,      /* tp_compare */
1791         (reprfunc)PySwigPacked_repr,        /* tp_repr */
1792         0,                                  /* tp_as_number */
1793         0,                                  /* tp_as_sequence */
1794         0,                                  /* tp_as_mapping */
1795         (hashfunc)0,                        /* tp_hash */
1796         (ternaryfunc)0,                     /* tp_call */
1797         (reprfunc)PySwigPacked_str,         /* tp_str */
1798         PyObject_GenericGetAttr,            /* tp_getattro */
1799         0,                                  /* tp_setattro */
1800         0,                                  /* tp_as_buffer */
1801         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1802         swigpacked_doc,                     /* tp_doc */
1803         0,                                  /* tp_traverse */
1804         0,                                  /* tp_clear */
1805         0,                                  /* tp_richcompare */
1806         0,                                  /* tp_weaklistoffset */
1807 #if PY_VERSION_HEX >= 0x02020000
1808         0,                                  /* tp_iter */
1809         0,                                  /* tp_iternext */
1810         0,                                  /* tp_methods */
1811         0,                                  /* tp_members */
1812         0,                                  /* tp_getset */
1813         0,                                  /* tp_base */
1814         0,                                  /* tp_dict */
1815         0,                                  /* tp_descr_get */
1816         0,                                  /* tp_descr_set */
1817         0,                                  /* tp_dictoffset */
1818         0,                                  /* tp_init */
1819         0,                                  /* tp_alloc */
1820         0,                                  /* tp_new */
1821         0,                                  /* tp_free */
1822         0,                                  /* tp_is_gc */
1823         0,                                  /* tp_bases */
1824         0,                                  /* tp_mro */
1825         0,                                  /* tp_cache */
1826         0,                                  /* tp_subclasses */
1827         0,                                  /* tp_weaklist */
1828 #endif
1829 #if PY_VERSION_HEX >= 0x02030000
1830         0,                                  /* tp_del */
1831 #endif
1832 #ifdef COUNT_ALLOCS
1833         0,0,0,0                             /* tp_alloc -> tp_next */
1834 #endif
1835       };
1836     pyswigpacked_type = tmp;
1837     pyswigpacked_type.ob_type = &PyType_Type;
1838     type_init = 1;
1839   }
1840   return &pyswigpacked_type;
1841 }
1842
1843 SWIGRUNTIME PyObject *
1844 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1845 {
1846   PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1847   if (sobj) {
1848     void *pack = malloc(size);
1849     if (pack) {
1850       memcpy(pack, ptr, size);
1851       sobj->pack = pack;
1852       sobj->ty   = ty;
1853       sobj->size = size;
1854     } else {
1855       PyObject_DEL((PyObject *) sobj);
1856       sobj = 0;
1857     }
1858   }
1859   return (PyObject *) sobj;
1860 }
1861
1862 SWIGRUNTIME swig_type_info *
1863 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1864 {
1865   if (PySwigPacked_Check(obj)) {
1866     PySwigPacked *sobj = (PySwigPacked *)obj;
1867     if (sobj->size != size) return 0;
1868     memcpy(ptr, sobj->pack, size);
1869     return sobj->ty;
1870   } else {
1871     return 0;
1872   }
1873 }
1874
1875 /* -----------------------------------------------------------------------------
1876  * pointers/data manipulation
1877  * ----------------------------------------------------------------------------- */
1878
1879 SWIGRUNTIMEINLINE PyObject *
1880 _SWIG_This(void)
1881 {
1882   return PyString_FromString("this");
1883 }
1884
1885 SWIGRUNTIME PyObject *
1886 SWIG_This(void)
1887 {
1888   static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1889   return swig_this;
1890 }
1891
1892 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1893
1894 SWIGRUNTIME PySwigObject *
1895 SWIG_Python_GetSwigThis(PyObject *pyobj)
1896 {
1897   if (PySwigObject_Check(pyobj)) {
1898     return (PySwigObject *) pyobj;
1899   } else {
1900     PyObject *obj = 0;
1901 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1902     if (PyInstance_Check(pyobj)) {
1903       obj = _PyInstance_Lookup(pyobj, SWIG_This());
1904     } else {
1905       PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1906       if (dictptr != NULL) {
1907         PyObject *dict = *dictptr;
1908         obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1909       } else {
1910 #ifdef PyWeakref_CheckProxy
1911         if (PyWeakref_CheckProxy(pyobj)) {
1912           PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1913           return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1914         }
1915 #endif
1916         obj = PyObject_GetAttr(pyobj,SWIG_This());
1917         if (obj) {
1918           Py_DECREF(obj);
1919         } else {
1920           if (PyErr_Occurred()) PyErr_Clear();
1921           return 0;
1922         }
1923       }
1924     }
1925 #else
1926     obj = PyObject_GetAttr(pyobj,SWIG_This());
1927     if (obj) {
1928       Py_DECREF(obj);
1929     } else {
1930       if (PyErr_Occurred()) PyErr_Clear();
1931       return 0;
1932     }
1933 #endif
1934     if (obj && !PySwigObject_Check(obj)) {
1935       /* a PyObject is called 'this', try to get the 'real this'
1936          PySwigObject from it */
1937       return SWIG_Python_GetSwigThis(obj);
1938     }
1939     return (PySwigObject *)obj;
1940   }
1941 }
1942
1943 /* Acquire a pointer value */
1944
1945 SWIGRUNTIME int
1946 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1947   if (own) {
1948     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1949     if (sobj) {
1950       int oldown = sobj->own;
1951       sobj->own = own;
1952       return oldown;
1953     }
1954   }
1955   return 0;
1956 }
1957
1958 /* Convert a pointer value */
1959
1960 SWIGRUNTIME int
1961 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1962   if (!obj) return SWIG_ERROR;
1963   if (obj == Py_None) {
1964     if (ptr) *ptr = 0;
1965     return SWIG_OK;
1966   } else {
1967     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1968     while (sobj) {
1969       void *vptr = sobj->ptr;
1970       if (ty) {
1971         swig_type_info *to = sobj->ty;
1972         if (to == ty) {
1973           /* no type cast needed */
1974           if (ptr) *ptr = vptr;
1975           break;
1976         } else {
1977           swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1978           if (!tc) {
1979             sobj = (PySwigObject *)sobj->next;
1980           } else {
1981             if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1982             break;
1983           }
1984         }
1985       } else {
1986         if (ptr) *ptr = vptr;
1987         break;
1988       }
1989     }
1990     if (sobj) {
1991       if (own) *own = sobj->own;
1992       if (flags & SWIG_POINTER_DISOWN) {
1993         sobj->own = 0;
1994       }
1995       return SWIG_OK;
1996     } else {
1997       int res = SWIG_ERROR;
1998       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
1999         PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2000         if (data && !data->implicitconv) {
2001           PyObject *klass = data->klass;
2002           if (klass) {
2003             PyObject *impconv;
2004             data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2005             impconv = SWIG_Python_CallFunctor(klass, obj);
2006             data->implicitconv = 0;
2007             if (PyErr_Occurred()) {
2008               PyErr_Clear();
2009               impconv = 0;
2010             }
2011             if (impconv) {
2012               PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2013               if (iobj) {
2014                 void *vptr;
2015                 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2016                 if (SWIG_IsOK(res)) {
2017                   if (ptr) {
2018                     *ptr = vptr;
2019                     /* transfer the ownership to 'ptr' */
2020                     iobj->own = 0;
2021                     res = SWIG_AddCast(res);
2022                     res = SWIG_AddNewMask(res);
2023                   } else {
2024                     res = SWIG_AddCast(res);
2025                   }
2026                 }
2027               }
2028               Py_DECREF(impconv);
2029             }
2030           }
2031         }
2032       }
2033       return res;
2034     }
2035   }
2036 }
2037
2038 /* Convert a function ptr value */
2039
2040 SWIGRUNTIME int
2041 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2042   if (!PyCFunction_Check(obj)) {
2043     return SWIG_ConvertPtr(obj, ptr, ty, 0);
2044   } else {
2045     void *vptr = 0;
2046
2047     /* here we get the method pointer for callbacks */
2048     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2049     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2050     if (desc) {
2051       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2052       if (!desc) return SWIG_ERROR;
2053     }
2054     if (ty) {
2055       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2056       if (!tc) return SWIG_ERROR;
2057       *ptr = SWIG_TypeCast(tc,vptr);
2058     } else {
2059       *ptr = vptr;
2060     }
2061     return SWIG_OK;
2062   }
2063 }
2064
2065 /* Convert a packed value value */
2066
2067 SWIGRUNTIME int
2068 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2069   swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2070   if (!to) return SWIG_ERROR;
2071   if (ty) {
2072     if (to != ty) {
2073       /* check type cast? */
2074       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2075       if (!tc) return SWIG_ERROR;
2076     }
2077   }
2078   return SWIG_OK;
2079 }
2080
2081 /* -----------------------------------------------------------------------------
2082  * Create a new pointer object
2083  * ----------------------------------------------------------------------------- */
2084
2085 /*
2086   Create a new instance object, whitout calling __init__, and set the
2087   'this' attribute.
2088 */
2089
2090 SWIGRUNTIME PyObject*
2091 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2092 {
2093 #if (PY_VERSION_HEX >= 0x02020000)
2094   PyObject *inst = 0;
2095   PyObject *newraw = data->newraw;
2096   if (newraw) {
2097     inst = PyObject_Call(newraw, data->newargs, NULL);
2098     if (inst) {
2099 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2100       PyObject **dictptr = _PyObject_GetDictPtr(inst);
2101       if (dictptr != NULL) {
2102         PyObject *dict = *dictptr;
2103         if (dict == NULL) {
2104           dict = PyDict_New();
2105           *dictptr = dict;
2106           PyDict_SetItem(dict, SWIG_This(), swig_this);
2107         }
2108       }
2109 #else
2110       PyObject *key = SWIG_This();
2111       PyObject_SetAttr(inst, key, swig_this);
2112 #endif
2113     }
2114   } else {
2115     PyObject *dict = PyDict_New();
2116     PyDict_SetItem(dict, SWIG_This(), swig_this);
2117     inst = PyInstance_NewRaw(data->newargs, dict);
2118     Py_DECREF(dict);
2119   }
2120   return inst;
2121 #else
2122 #if (PY_VERSION_HEX >= 0x02010000)
2123   PyObject *inst;
2124   PyObject *dict = PyDict_New();
2125   PyDict_SetItem(dict, SWIG_This(), swig_this);
2126   inst = PyInstance_NewRaw(data->newargs, dict);
2127   Py_DECREF(dict);
2128   return (PyObject *) inst;
2129 #else
2130   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2131   if (inst == NULL) {
2132     return NULL;
2133   }
2134   inst->in_class = (PyClassObject *)data->newargs;
2135   Py_INCREF(inst->in_class);
2136   inst->in_dict = PyDict_New();
2137   if (inst->in_dict == NULL) {
2138     Py_DECREF(inst);
2139     return NULL;
2140   }
2141 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2142   inst->in_weakreflist = NULL;
2143 #endif
2144 #ifdef Py_TPFLAGS_GC
2145   PyObject_GC_Init(inst);
2146 #endif
2147   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2148   return (PyObject *) inst;
2149 #endif
2150 #endif
2151 }
2152
2153 SWIGRUNTIME void
2154 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2155 {
2156  PyObject *dict;
2157 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2158  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2159  if (dictptr != NULL) {
2160    dict = *dictptr;
2161    if (dict == NULL) {
2162      dict = PyDict_New();
2163      *dictptr = dict;
2164    }
2165    PyDict_SetItem(dict, SWIG_This(), swig_this);
2166    return;
2167  }
2168 #endif
2169  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2170  PyDict_SetItem(dict, SWIG_This(), swig_this);
2171  Py_DECREF(dict);
2172 }
2173
2174
2175 SWIGINTERN PyObject *
2176 SWIG_Python_InitShadowInstance(PyObject *args) {
2177   PyObject *obj[2];
2178   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2179     return NULL;
2180   } else {
2181     PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2182     if (sthis) {
2183       PySwigObject_append((PyObject*) sthis, obj[1]);
2184     } else {
2185       SWIG_Python_SetSwigThis(obj[0], obj[1]);
2186     }
2187     return SWIG_Py_Void();
2188   }
2189 }
2190
2191 /* Create a new pointer object */
2192
2193 SWIGRUNTIME PyObject *
2194 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2195   if (!ptr) {
2196     return SWIG_Py_Void();
2197   } else {
2198     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2199     PyObject *robj = PySwigObject_New(ptr, type, own);
2200     PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2201     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2202       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2203       if (inst) {
2204         Py_DECREF(robj);
2205         robj = inst;
2206       }
2207     }
2208     return robj;
2209   }
2210 }
2211
2212 /* Create a new packed object */
2213
2214 SWIGRUNTIMEINLINE PyObject *
2215 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2216   return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2217 }
2218
2219 /* -----------------------------------------------------------------------------*
2220  *  Get type list
2221  * -----------------------------------------------------------------------------*/
2222
2223 #ifdef SWIG_LINK_RUNTIME
2224 void *SWIG_ReturnGlobalTypeList(void *);
2225 #endif
2226
2227 SWIGRUNTIME swig_module_info *
2228 SWIG_Python_GetModule(void) {
2229   static void *type_pointer = (void *)0;
2230   /* first check if module already created */
2231   if (!type_pointer) {
2232 #ifdef SWIG_LINK_RUNTIME
2233     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2234 #else
2235     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2236                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2237     if (PyErr_Occurred()) {
2238       PyErr_Clear();
2239       type_pointer = (void *)0;
2240     }
2241 #endif
2242   }
2243   return (swig_module_info *) type_pointer;
2244 }
2245
2246 #if PY_MAJOR_VERSION < 2
2247 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
2248    is copied out of Python/modsupport.c in python version 2.3.4 */
2249 SWIGINTERN int
2250 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2251 {
2252   PyObject *dict;
2253   if (!PyModule_Check(m)) {
2254     PyErr_SetString(PyExc_TypeError,
2255                     "PyModule_AddObject() needs module as first arg");
2256     return SWIG_ERROR;
2257   }
2258   if (!o) {
2259     PyErr_SetString(PyExc_TypeError,
2260                     "PyModule_AddObject() needs non-NULL value");
2261     return SWIG_ERROR;
2262   }
2263
2264   dict = PyModule_GetDict(m);
2265   if (dict == NULL) {
2266     /* Internal error -- modules must have a dict! */
2267     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2268                  PyModule_GetName(m));
2269     return SWIG_ERROR;
2270   }
2271   if (PyDict_SetItemString(dict, name, o))
2272     return SWIG_ERROR;
2273   Py_DECREF(o);
2274   return SWIG_OK;
2275 }
2276 #endif
2277
2278 SWIGRUNTIME void
2279 SWIG_Python_DestroyModule(void *vptr)
2280 {
2281   swig_module_info *swig_module = (swig_module_info *) vptr;
2282   swig_type_info **types = swig_module->types;
2283   size_t i;
2284   for (i =0; i < swig_module->size; ++i) {
2285     swig_type_info *ty = types[i];
2286     if (ty->owndata) {
2287       PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2288       if (data) PySwigClientData_Del(data);
2289     }
2290   }
2291   Py_DECREF(SWIG_This());
2292 }
2293
2294 SWIGRUNTIME void
2295 SWIG_Python_SetModule(swig_module_info *swig_module) {
2296   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2297
2298   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2299                                    swig_empty_runtime_method_table);
2300   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2301   if (pointer && module) {
2302     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2303   } else {
2304     Py_XDECREF(pointer);
2305   }
2306 }
2307
2308 /* The python cached type query */
2309 SWIGRUNTIME PyObject *
2310 SWIG_Python_TypeCache(void) {
2311   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2312   return cache;
2313 }
2314
2315 SWIGRUNTIME swig_type_info *
2316 SWIG_Python_TypeQuery(const char *type)
2317 {
2318   PyObject *cache = SWIG_Python_TypeCache();
2319   PyObject *key = PyString_FromString(type);
2320   PyObject *obj = PyDict_GetItem(cache, key);
2321   swig_type_info *descriptor;
2322   if (obj) {
2323     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2324   } else {
2325     swig_module_info *swig_module = SWIG_Python_GetModule();
2326     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2327     if (descriptor) {
2328       obj = PyCObject_FromVoidPtr(descriptor, NULL);
2329       PyDict_SetItem(cache, key, obj);
2330       Py_DECREF(obj);
2331     }
2332   }
2333   Py_DECREF(key);
2334   return descriptor;
2335 }
2336
2337 /*
2338    For backward compatibility only
2339 */
2340 #define SWIG_POINTER_EXCEPTION  0
2341 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2342 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2343
2344 SWIGRUNTIME int
2345 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2346 {
2347   if (PyErr_Occurred()) {
2348     PyObject *type = 0;
2349     PyObject *value = 0;
2350     PyObject *traceback = 0;
2351     PyErr_Fetch(&type, &value, &traceback);
2352     if (value) {
2353       PyObject *old_str = PyObject_Str(value);
2354       Py_XINCREF(type);
2355       PyErr_Clear();
2356       if (infront) {
2357         PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2358       } else {
2359         PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2360       }
2361       Py_DECREF(old_str);
2362     }
2363     return 1;
2364   } else {
2365     return 0;
2366   }
2367 }
2368
2369 SWIGRUNTIME int
2370 SWIG_Python_ArgFail(int argnum)
2371 {
2372   if (PyErr_Occurred()) {
2373     /* add information about failing argument */
2374     char mesg[256];
2375     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2376     return SWIG_Python_AddErrMesg(mesg, 1);
2377   } else {
2378     return 0;
2379   }
2380 }
2381
2382 SWIGRUNTIMEINLINE const char *
2383 PySwigObject_GetDesc(PyObject *self)
2384 {
2385   PySwigObject *v = (PySwigObject *)self;
2386   swig_type_info *ty = v ? v->ty : 0;
2387   return ty ? ty->str : (char*)"";
2388 }
2389
2390 SWIGRUNTIME void
2391 SWIG_Python_TypeError(const char *type, PyObject *obj)
2392 {
2393   if (type) {
2394 #if defined(SWIG_COBJECT_TYPES)
2395     if (obj && PySwigObject_Check(obj)) {
2396       const char *otype = (const char *) PySwigObject_GetDesc(obj);
2397       if (otype) {
2398         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2399                      type, otype);
2400         return;
2401       }
2402     } else
2403 #endif
2404     {
2405       const char *otype = (obj ? obj->ob_type->tp_name : 0);
2406       if (otype) {
2407         PyObject *str = PyObject_Str(obj);
2408         const char *cstr = str ? PyString_AsString(str) : 0;
2409         if (cstr) {
2410           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2411                        type, otype, cstr);
2412         } else {
2413           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2414                        type, otype);
2415         }
2416         Py_XDECREF(str);
2417         return;
2418       }
2419     }
2420     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2421   } else {
2422     PyErr_Format(PyExc_TypeError, "unexpected type is received");
2423   }
2424 }
2425
2426
2427 /* Convert a pointer value, signal an exception on a type mismatch */
2428 SWIGRUNTIME void *
2429 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2430   void *result;
2431   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2432     PyErr_Clear();
2433     if (flags & SWIG_POINTER_EXCEPTION) {
2434       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2435       SWIG_Python_ArgFail(argnum);
2436     }
2437   }
2438   return result;
2439 }
2440
2441
2442 #ifdef __cplusplus
2443 #if 0
2444 { /* cc-mode */
2445 #endif
2446 }
2447 #endif
2448
2449
2450
2451 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2452
2453 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2454
2455
2456
2457   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_TALLOC_CTX swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_ldb_context swig_types[4]
2467 #define SWIGTYPE_p_ldb_dn swig_types[5]
2468 #define SWIGTYPE_p_ldb_ldif swig_types[6]
2469 #define SWIGTYPE_p_ldb_message swig_types[7]
2470 #define SWIGTYPE_p_ldb_message_element swig_types[8]
2471 #define SWIGTYPE_p_ldb_module_ops swig_types[9]
2472 #define SWIGTYPE_p_ldb_result swig_types[10]
2473 #define SWIGTYPE_p_ldb_val swig_types[11]
2474 #define SWIGTYPE_p_long_long swig_types[12]
2475 #define SWIGTYPE_p_p_char swig_types[13]
2476 #define SWIGTYPE_p_p_ldb_control swig_types[14]
2477 #define SWIGTYPE_p_p_ldb_result swig_types[15]
2478 #define SWIGTYPE_p_short swig_types[16]
2479 #define SWIGTYPE_p_signed_char swig_types[17]
2480 #define SWIGTYPE_p_unsigned_char swig_types[18]
2481 #define SWIGTYPE_p_unsigned_int swig_types[19]
2482 #define SWIGTYPE_p_unsigned_long swig_types[20]
2483 #define SWIGTYPE_p_unsigned_long_long swig_types[21]
2484 #define SWIGTYPE_p_unsigned_short swig_types[22]
2485 #define SWIGTYPE_p_void swig_types[23]
2486 static swig_type_info *swig_types[25];
2487 static swig_module_info swig_module = {swig_types, 24, 0, 0, 0, 0};
2488 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2489 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2490
2491 /* -------- TYPES TABLE (END) -------- */
2492
2493 #if (PY_VERSION_HEX <= 0x02000000)
2494 # if !defined(SWIG_PYTHON_CLASSIC)
2495 #  error "This python version requires swig to be run with the '-classic' option"
2496 # endif
2497 #endif
2498 #if (PY_VERSION_HEX <= 0x02020000)
2499 # error "This python version requires swig to be run with the '-nomodern' option"
2500 #endif
2501 #if (PY_VERSION_HEX <= 0x02020000)
2502 # error "This python version requires swig to be run with the '-nomodernargs' option"
2503 #endif
2504 #ifndef METH_O
2505 # error "This python version requires swig to be run with the '-nofastunpack' option"
2506 #endif
2507 #ifdef SWIG_TypeQuery
2508 # undef SWIG_TypeQuery
2509 #endif
2510 #define SWIG_TypeQuery SWIG_Python_TypeQuery
2511
2512 /*-----------------------------------------------
2513               @(target):= _ldb.so
2514   ------------------------------------------------*/
2515 #define SWIG_init    init_ldb
2516
2517 #define SWIG_name    "_ldb"
2518
2519 #define SWIGVERSION 0x010333
2520 #define SWIG_VERSION SWIGVERSION
2521
2522
2523 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2524 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2525
2526
2527
2528 #include <stdint.h>
2529 #include <stdbool.h>
2530 #include "talloc.h"
2531 #include "ldb.h"
2532 #include "ldb_errors.h"
2533 #include "ldb_private.h"
2534
2535 typedef struct ldb_message ldb_msg;
2536 typedef struct ldb_context ldb;
2537 typedef struct ldb_dn ldb_dn;
2538 typedef struct ldb_ldif ldb_ldif;
2539 typedef struct ldb_message_element ldb_msg_element;
2540 typedef int ldb_error;
2541
2542
2543
2544   #define SWIG_From_long   PyInt_FromLong
2545
2546
2547 SWIGINTERNINLINE PyObject *
2548 SWIG_From_int  (int value)
2549 {
2550   return SWIG_From_long  (value);
2551 }
2552
2553
2554 PyObject *ldb_val_to_py_object(struct ldb_context *ldb_ctx,
2555                                struct ldb_message_element *el,
2556                                struct ldb_val *val)
2557 {
2558         const struct ldb_schema_attribute *a;
2559         struct ldb_val new_val;
2560         TALLOC_CTX *mem_ctx = talloc_new(NULL);
2561         PyObject *ret;
2562
2563         new_val = *val;
2564
2565         if (ldb_ctx != NULL) {
2566                 a = ldb_schema_attribute_by_name(ldb_ctx, el->name);
2567
2568                 if (a != NULL) {
2569                         if (a->syntax->ldif_write_fn(ldb_ctx, mem_ctx, val, &new_val) != 0) {
2570                                 talloc_free(mem_ctx);
2571                                 return NULL;
2572                         }
2573                 }
2574         }
2575
2576         ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
2577
2578         talloc_free(mem_ctx);
2579
2580         return ret;
2581 }
2582
2583
2584
2585 SWIGINTERN swig_type_info*
2586 SWIG_pchar_descriptor(void)
2587 {
2588   static int init = 0;
2589   static swig_type_info* info = 0;
2590   if (!init) {
2591     info = SWIG_TypeQuery("_p_char");
2592     init = 1;
2593   }
2594   return info;
2595 }
2596
2597
2598 SWIGINTERN int
2599 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2600 {
2601   if (PyString_Check(obj)) {
2602     char *cstr; Py_ssize_t len;
2603     PyString_AsStringAndSize(obj, &cstr, &len);
2604     if (cptr)  {
2605       if (alloc) {
2606         /*
2607            In python the user should not be able to modify the inner
2608            string representation. To warranty that, if you define
2609            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
2610            buffer is always returned.
2611
2612            The default behavior is just to return the pointer value,
2613            so, be careful.
2614         */
2615 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
2616         if (*alloc != SWIG_OLDOBJ)
2617 #else
2618         if (*alloc == SWIG_NEWOBJ)
2619 #endif
2620           {
2621             *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
2622             *alloc = SWIG_NEWOBJ;
2623           }
2624         else {
2625           *cptr = cstr;
2626           *alloc = SWIG_OLDOBJ;
2627         }
2628       } else {
2629         *cptr = PyString_AsString(obj);
2630       }
2631     }
2632     if (psize) *psize = len + 1;
2633     return SWIG_OK;
2634   } else {
2635     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2636     if (pchar_descriptor) {
2637       void* vptr = 0;
2638       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
2639         if (cptr) *cptr = (char *) vptr;
2640         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
2641         if (alloc) *alloc = SWIG_OLDOBJ;
2642         return SWIG_OK;
2643       }
2644     }
2645   }
2646   return SWIG_TypeError;
2647 }
2648
2649
2650
2651
2652 SWIGINTERN ldb_dn *new_ldb_dn(ldb *ldb_ctx,char const *str){
2653             ldb_dn *ret = ldb_dn_new(ldb_ctx, ldb_ctx, str);
2654             /* ldb_dn_new() doesn't accept NULL as memory context, so
2655                we do it this way... */
2656             talloc_steal(NULL, ret);
2657
2658             if (ret == NULL)
2659                 SWIG_exception(SWIG_ValueError,
2660                                 "unable to parse dn string");
2661 fail:
2662             return ret;
2663         }
2664 SWIGINTERN void delete_ldb_dn(ldb_dn *self){ talloc_free(self); }
2665
2666 SWIGINTERNINLINE PyObject*
2667   SWIG_From_bool  (bool value)
2668 {
2669   return PyBool_FromLong(value ? 1 : 0);
2670 }
2671
2672
2673 SWIGINTERNINLINE PyObject *
2674 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2675 {
2676   if (carray) {
2677     if (size > INT_MAX) {
2678       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2679       return pchar_descriptor ?
2680         SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2681     } else {
2682       return PyString_FromStringAndSize(carray, (int)(size));
2683     }
2684   } else {
2685     return SWIG_Py_Void();
2686   }
2687 }
2688
2689
2690 SWIGINTERNINLINE PyObject *
2691 SWIG_FromCharPtr(const char *cptr)
2692 {
2693   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2694 }
2695
2696 SWIGINTERN ldb_dn *ldb_dn_parent(ldb_dn *self){ return ldb_dn_get_parent(NULL, self); }
2697 SWIGINTERN char const *ldb_dn_canonical_str(ldb_dn *self){
2698             return ldb_dn_canonical_string(self, self);
2699         }
2700 SWIGINTERN char const *ldb_dn_canonical_ex_str(ldb_dn *self){
2701             return ldb_dn_canonical_ex_string(self, self);
2702         }
2703 SWIGINTERN ldb_dn *ldb_dn___add__(ldb_dn *self,ldb_dn *other){
2704             ldb_dn *ret = ldb_dn_copy(NULL, self);
2705             ldb_dn_add_child(ret, other);
2706             return ret;
2707         }
2708
2709 int ldb_dn_from_pyobject(TALLOC_CTX *mem_ctx, PyObject *object,
2710                          struct ldb_context *ldb_ctx, ldb_dn **dn)
2711 {
2712     int ret;
2713     struct ldb_dn *odn;
2714     if (ldb_ctx != NULL && PyString_Check(object)) {
2715         *dn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object));
2716         return 0;
2717     }
2718     ret = SWIG_ConvertPtr(object, (void **)&odn, SWIGTYPE_p_ldb_dn,
2719                            SWIG_POINTER_EXCEPTION);
2720     *dn = ldb_dn_copy(mem_ctx, odn);
2721     return ret;
2722 }
2723
2724 ldb_msg_element *ldb_msg_element_from_pyobject(TALLOC_CTX *mem_ctx,
2725                                                PyObject *set_obj, int flags,
2726                                                const char *attr_name)
2727 {
2728     struct ldb_message_element *me = talloc(mem_ctx, struct ldb_message_element);
2729     me->name = attr_name;
2730     me->flags = flags;
2731     if (PyString_Check(set_obj)) {
2732         me->num_values = 1;
2733         me->values = talloc_array(me, struct ldb_val, me->num_values);
2734         me->values[0].length = PyString_Size(set_obj);
2735         me->values[0].data = (uint8_t *)talloc_strdup(me->values,
2736                                            PyString_AsString(set_obj));
2737     } else if (PySequence_Check(set_obj)) {
2738         int i;
2739         me->num_values = PySequence_Size(set_obj);
2740         me->values = talloc_array(me, struct ldb_val, me->num_values);
2741         for (i = 0; i < me->num_values; i++) {
2742             PyObject *obj = PySequence_GetItem(set_obj, i);
2743             me->values[i].length = PyString_Size(obj);
2744             me->values[i].data = (uint8_t *)PyString_AsString(obj);
2745         }
2746     } else {
2747         talloc_free(me);
2748         me = NULL;
2749     }
2750
2751     return me;
2752 }
2753
2754 PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx,
2755                                  ldb_msg_element *me)
2756 {
2757     int i;
2758     PyObject *result;
2759
2760     /* Python << 2.5 doesn't have PySet_New and PySet_Add. */
2761     result = PyList_New(me->num_values);
2762
2763     for (i = 0; i < me->num_values; i++) {
2764         PyList_SetItem(result, i,
2765             ldb_val_to_py_object(ldb_ctx, me, &me->values[i]));
2766     }
2767
2768     return result;
2769 }
2770
2771
2772 SWIGINTERN PyObject *ldb_msg_element___iter__(ldb_msg_element *self){
2773             return PyObject_GetIter(ldb_msg_element_to_set(NULL, self));
2774         }
2775 SWIGINTERN PyObject *ldb_msg_element___set__(ldb_msg_element *self){
2776             return ldb_msg_element_to_set(NULL, self);
2777         }
2778
2779 #include <limits.h>
2780 #if !defined(SWIG_NO_LLONG_MAX)
2781 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2782 #   define LLONG_MAX __LONG_LONG_MAX__
2783 #   define LLONG_MIN (-LLONG_MAX - 1LL)
2784 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2785 # endif
2786 #endif
2787
2788
2789 SWIGINTERN int
2790 SWIG_AsVal_double (PyObject *obj, double *val)
2791 {
2792   int res = SWIG_TypeError;
2793   if (PyFloat_Check(obj)) {
2794     if (val) *val = PyFloat_AsDouble(obj);
2795     return SWIG_OK;
2796   } else if (PyInt_Check(obj)) {
2797     if (val) *val = PyInt_AsLong(obj);
2798     return SWIG_OK;
2799   } else if (PyLong_Check(obj)) {
2800     double v = PyLong_AsDouble(obj);
2801     if (!PyErr_Occurred()) {
2802       if (val) *val = v;
2803       return SWIG_OK;
2804     } else {
2805       PyErr_Clear();
2806     }
2807   }
2808 #ifdef SWIG_PYTHON_CAST_MODE
2809   {
2810     int dispatch = 0;
2811     double d = PyFloat_AsDouble(obj);
2812     if (!PyErr_Occurred()) {
2813       if (val) *val = d;
2814       return SWIG_AddCast(SWIG_OK);
2815     } else {
2816       PyErr_Clear();
2817     }
2818     if (!dispatch) {
2819       long v = PyLong_AsLong(obj);
2820       if (!PyErr_Occurred()) {
2821         if (val) *val = v;
2822         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2823       } else {
2824         PyErr_Clear();
2825       }
2826     }
2827   }
2828 #endif
2829   return res;
2830 }
2831
2832
2833 #include <float.h>
2834
2835
2836 #include <math.h>
2837
2838
2839 SWIGINTERNINLINE int
2840 SWIG_CanCastAsInteger(double *d, double min, double max) {
2841   double x = *d;
2842   if ((min <= x && x <= max)) {
2843    double fx = floor(x);
2844    double cx = ceil(x);
2845    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2846    if ((errno == EDOM) || (errno == ERANGE)) {
2847      errno = 0;
2848    } else {
2849      double summ, reps, diff;
2850      if (rd < x) {
2851        diff = x - rd;
2852      } else if (rd > x) {
2853        diff = rd - x;
2854      } else {
2855        return 1;
2856      }
2857      summ = rd + x;
2858      reps = diff/summ;
2859      if (reps < 8*DBL_EPSILON) {
2860        *d = rd;
2861        return 1;
2862      }
2863    }
2864   }
2865   return 0;
2866 }
2867
2868
2869 SWIGINTERN int
2870 SWIG_AsVal_long (PyObject *obj, long* val)
2871 {
2872   if (PyInt_Check(obj)) {
2873     if (val) *val = PyInt_AsLong(obj);
2874     return SWIG_OK;
2875   } else if (PyLong_Check(obj)) {
2876     long v = PyLong_AsLong(obj);
2877     if (!PyErr_Occurred()) {
2878       if (val) *val = v;
2879       return SWIG_OK;
2880     } else {
2881       PyErr_Clear();
2882     }
2883   }
2884 #ifdef SWIG_PYTHON_CAST_MODE
2885   {
2886     int dispatch = 0;
2887     long v = PyInt_AsLong(obj);
2888     if (!PyErr_Occurred()) {
2889       if (val) *val = v;
2890       return SWIG_AddCast(SWIG_OK);
2891     } else {
2892       PyErr_Clear();
2893     }
2894     if (!dispatch) {
2895       double d;
2896       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2897       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2898         if (val) *val = (long)(d);
2899         return res;
2900       }
2901     }
2902   }
2903 #endif
2904   return SWIG_TypeError;
2905 }
2906
2907
2908 SWIGINTERN int
2909 SWIG_AsVal_int (PyObject * obj, int *val)
2910 {
2911   long v;
2912   int res = SWIG_AsVal_long (obj, &v);
2913   if (SWIG_IsOK(res)) {
2914     if ((v < INT_MIN || v > INT_MAX)) {
2915       return SWIG_OverflowError;
2916     } else {
2917       if (val) *val = (int)(v);
2918     }
2919   }
2920   return res;
2921 }
2922
2923 SWIGINTERN ldb_msg_element *new_ldb_msg_element(PyObject *set_obj,int flags,char const *name){
2924             return ldb_msg_element_from_pyobject(NULL, set_obj, flags, name);
2925         }
2926 SWIGINTERN int ldb_msg_element___len__(ldb_msg_element *self){
2927             return self->num_values;
2928         }
2929 SWIGINTERN PyObject *ldb_msg_element_get(ldb_msg_element *self,int i){
2930             if (i < 0 || i >= self->num_values)
2931                 return Py_None;
2932
2933             return ldb_val_to_py_object(NULL, self, &self->values[i]);
2934         }
2935 SWIGINTERN void delete_ldb_msg_element(ldb_msg_element *self){ talloc_free(self); }
2936
2937     PyObject *ldb_msg_list_elements(ldb_msg *msg)
2938     {
2939         int i;
2940         PyObject *obj = PyList_New(msg->num_elements);
2941         for (i = 0; i < msg->num_elements; i++)
2942             PyList_SetItem(obj, i, PyString_FromString(msg->elements[i].name));
2943         return obj;
2944     }
2945
2946 SWIGINTERN ldb_msg *new_ldb_msg(ldb_dn *dn){
2947             ldb_msg *ret = ldb_msg_new(NULL);
2948             ret->dn = talloc_reference(ret, dn);
2949             return ret;
2950         }
2951 SWIGINTERN void delete_ldb_msg(ldb_msg *self){ talloc_free(self); }
2952 SWIGINTERN void ldb_msg___setitem____SWIG_0(ldb_msg *self,char const *attr_name,ldb_msg_element *val){
2953             struct ldb_message_element *el;
2954
2955             ldb_msg_remove_attr(self, attr_name);
2956
2957             el = talloc(self, struct ldb_message_element);
2958             el->name = talloc_strdup(el, attr_name);
2959             el->num_values = val->num_values;
2960             el->values = talloc_reference(el, val->values);
2961
2962             ldb_msg_add(self, el, val->flags);
2963         }
2964 SWIGINTERN void ldb_msg___setitem____SWIG_1(ldb_msg *self,char const *attr_name,PyObject *val){
2965             struct ldb_message_element *el = ldb_msg_element_from_pyobject(NULL,
2966                                                 val, 0, attr_name);
2967             talloc_steal(self, el);
2968             ldb_msg_remove_attr(self, attr_name);
2969             ldb_msg_add(self, el, el->flags);
2970         }
2971 SWIGINTERN unsigned int ldb_msg___len__(ldb_msg *self){ return self->num_elements; }
2972
2973 SWIGINTERNINLINE PyObject*
2974 SWIG_From_unsigned_SS_long  (unsigned long value)
2975 {
2976   return (value > LONG_MAX) ?
2977     PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
2978 }
2979
2980
2981 SWIGINTERNINLINE PyObject *
2982 SWIG_From_unsigned_SS_int  (unsigned int value)
2983 {
2984   return SWIG_From_unsigned_SS_long  (value);
2985 }
2986
2987 SWIGINTERN PyObject *ldb_msg_keys(ldb_msg *self){
2988             return ldb_msg_list_elements(self);
2989         }
2990 SWIGINTERN PyObject *ldb_msg___iter__(ldb_msg *self){
2991             return PyObject_GetIter(ldb_msg_list_elements(self));
2992         }
2993
2994 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
2995 {
2996     char *text;
2997     PyObject *fn = context;
2998
2999     vasprintf(&text, fmt, ap);
3000     PyObject_CallFunction(fn, (char *)"(i,s)", level, text);
3001     free(text);
3002 }
3003
3004
3005     static PyObject *ldb_ldif_to_pyobject(ldb_ldif *ldif)
3006     {
3007         if (ldif == NULL) {
3008             return Py_None;
3009         } else {
3010             return Py_BuildValue((char *)"(iO)", ldif->changetype,
3011                    SWIG_NewPointerObj(ldif->msg, SWIGTYPE_p_ldb_message, 0));
3012         }
3013     }
3014
3015
3016 PyObject *PyExc_LdbError;
3017
3018 SWIGINTERN ldb *new_ldb(){ return ldb_init(NULL); }
3019
3020 SWIGINTERN int
3021 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3022 {
3023   if (PyInt_Check(obj)) {
3024     long v = PyInt_AsLong(obj);
3025     if (v >= 0) {
3026       if (val) *val = v;
3027       return SWIG_OK;
3028     } else {
3029       return SWIG_OverflowError;
3030     }
3031   } else if (PyLong_Check(obj)) {
3032     unsigned long v = PyLong_AsUnsignedLong(obj);
3033     if (!PyErr_Occurred()) {
3034       if (val) *val = v;
3035       return SWIG_OK;
3036     } else {
3037       PyErr_Clear();
3038     }
3039   }
3040 #ifdef SWIG_PYTHON_CAST_MODE
3041   {
3042     int dispatch = 0;
3043     unsigned long v = PyLong_AsUnsignedLong(obj);
3044     if (!PyErr_Occurred()) {
3045       if (val) *val = v;
3046       return SWIG_AddCast(SWIG_OK);
3047     } else {
3048       PyErr_Clear();
3049     }
3050     if (!dispatch) {
3051       double d;
3052       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3053       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3054         if (val) *val = (unsigned long)(d);
3055         return res;
3056       }
3057     }
3058   }
3059 #endif
3060   return SWIG_TypeError;
3061 }
3062
3063
3064 SWIGINTERN int
3065 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3066 {
3067   unsigned long v;
3068   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3069   if (SWIG_IsOK(res)) {
3070     if ((v > UINT_MAX)) {
3071       return SWIG_OverflowError;
3072     } else {
3073       if (val) *val = (unsigned int)(v);
3074     }
3075   }
3076   return res;
3077 }
3078
3079 SWIGINTERN void delete_ldb(ldb *self){ talloc_free(self); }
3080 SWIGINTERN ldb_error ldb_search_ex(ldb *self,TALLOC_CTX *mem_ctx,ldb_dn *base,enum ldb_scope scope,char const *expression,char const *const *attrs,struct ldb_control **controls,struct ldb_result **OUT){
3081             int ret;
3082             struct ldb_result *res;
3083             struct ldb_request *req;
3084             res = talloc_zero(mem_ctx, struct ldb_result);
3085             if (!res) {
3086                 return 1;
3087             }
3088
3089             ret = ldb_build_search_req(&req, self, mem_ctx,
3090                            base?base:ldb_get_default_basedn(self),
3091                            scope,
3092                            expression,
3093                            attrs,
3094                            controls,
3095                            res,
3096                            ldb_search_default_callback);
3097
3098             if (ret != 0) {
3099                 talloc_free(res);
3100                 return ret;
3101             }
3102
3103             ldb_set_timeout(self, req, 0); /* use default timeout */
3104
3105             ret = ldb_request(self, req);
3106
3107             if (ret == 0) {
3108                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
3109             }
3110
3111             talloc_free(req);
3112
3113             *OUT = res;
3114             return ret;
3115         }
3116 SWIGINTERN ldb_error ldb_add__SWIG_1(ldb *self,PyObject *py_msg){
3117             ldb_error ret;
3118             int dict_pos, msg_pos;
3119             PyObject *key, *value;
3120             ldb_msg_element *msgel;
3121             ldb_msg *msg = NULL;
3122
3123             if (PyDict_Check(py_msg)) {
3124                 msg = ldb_msg_new(NULL);
3125                 msg->elements = talloc_zero_array(msg, struct ldb_message_element, PyDict_Size(py_msg));
3126                 msg_pos = dict_pos = 0;
3127                 while (PyDict_Next(py_msg, &dict_pos, &key, &value)) {
3128                     if (!strcmp(PyString_AsString(key), "dn")) {
3129                         if (ldb_dn_from_pyobject(msg, value, self, &msg->dn) != 0) {
3130                             return 80;
3131                         }
3132                     } else {
3133                         msgel = ldb_msg_element_from_pyobject(msg->elements, value, 0, PyString_AsString(key));
3134                         if (msgel == NULL) {
3135                             SWIG_exception(SWIG_TypeError, "unable to import element");
3136                             return 80;
3137                         }
3138                         memcpy(&msg->elements[msg_pos], msgel, sizeof(*msgel));
3139                         msg_pos++;
3140                     }
3141                 }
3142
3143                 if (msg->dn == NULL) {
3144                     SWIG_exception(SWIG_TypeError, "no dn set");
3145                     return 80;
3146                 }
3147
3148                 msg->num_elements = msg_pos;
3149             } else {
3150                 if (SWIG_ConvertPtr(py_msg, (void **)&msg, SWIGTYPE_p_ldb_message, 0) != 0)
3151                     return 80;
3152             }
3153
3154             ret = ldb_add(self, msg);
3155
3156             talloc_free(msg);
3157             return ret;
3158
3159             fail:
3160             return 80;
3161         }
3162 SWIGINTERN PyObject *ldb_schema_format_value(ldb *self,char const *element_name,PyObject *val){
3163                 const struct ldb_schema_attribute *a;
3164                 struct ldb_val old_val;
3165                 struct ldb_val new_val;
3166                 TALLOC_CTX *mem_ctx = talloc_new(NULL);
3167                 PyObject *ret;
3168
3169                 old_val.data = PyString_AsString(val);
3170                 old_val.length = PyString_Size(val);
3171
3172                 a = ldb_schema_attribute_by_name(self, element_name);
3173
3174                 if (a == NULL) {
3175                         return Py_None;
3176                 }
3177
3178                 if (a->syntax->ldif_write_fn(self, mem_ctx, &old_val, &new_val) != 0) {
3179                         talloc_free(mem_ctx);
3180                         return Py_None;
3181                  }
3182
3183                 ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
3184
3185                 talloc_free(mem_ctx);
3186
3187                 return ret;
3188         }
3189 SWIGINTERN ldb_error ldb___contains__(ldb *self,ldb_dn *dn,struct ldb_result **result_as_bool){
3190             return ldb_search(self, dn, LDB_SCOPE_BASE, NULL, NULL,
3191                              result_as_bool);
3192         }
3193 SWIGINTERN PyObject *ldb_parse_ldif(ldb *self,char const *s){
3194             PyObject *list = PyList_New(0);
3195             struct ldb_ldif *ldif;
3196             while ((ldif = ldb_ldif_read_string(self, &s)) != NULL) {
3197                 PyList_Append(list, ldb_ldif_to_pyobject(ldif));
3198             }
3199             return PyObject_GetIter(list);
3200         }
3201
3202 static char *timestring(time_t t)
3203 {
3204     char *tresult = ldb_timestring(NULL, t);
3205     char *result = strdup(tresult);
3206     talloc_free(tresult);
3207     return result;
3208 }
3209
3210 #ifdef __cplusplus
3211 extern "C" {
3212 #endif
3213 SWIGINTERN PyObject *_wrap_ldb_val_to_py_object(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3214   PyObject *resultobj = 0;
3215   struct ldb_context *arg1 = (struct ldb_context *) 0 ;
3216   struct ldb_message_element *arg2 = (struct ldb_message_element *) 0 ;
3217   struct ldb_val *arg3 = (struct ldb_val *) 0 ;
3218   PyObject *result = 0 ;
3219   void *argp1 = 0 ;
3220   int res1 = 0 ;
3221   void *argp2 = 0 ;
3222   int res2 = 0 ;
3223   void *argp3 = 0 ;
3224   int res3 = 0 ;
3225   PyObject * obj0 = 0 ;
3226   PyObject * obj1 = 0 ;
3227   PyObject * obj2 = 0 ;
3228   char *  kwnames[] = {
3229     (char *) "ldb_ctx",(char *) "el",(char *) "val", NULL
3230   };
3231
3232   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ldb_val_to_py_object",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3233   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
3234   if (!SWIG_IsOK(res1)) {
3235     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_val_to_py_object" "', argument " "1"" of type '" "struct ldb_context *""'");
3236   }
3237   arg1 = (struct ldb_context *)(argp1);
3238   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3239   if (!SWIG_IsOK(res2)) {
3240     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_val_to_py_object" "', argument " "2"" of type '" "struct ldb_message_element *""'");
3241   }
3242   arg2 = (struct ldb_message_element *)(argp2);
3243   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ldb_val, 0 |  0 );
3244   if (!SWIG_IsOK(res3)) {
3245     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ldb_val_to_py_object" "', argument " "3"" of type '" "struct ldb_val *""'");
3246   }
3247   arg3 = (struct ldb_val *)(argp3);
3248   if (arg1 == NULL)
3249   SWIG_exception(SWIG_ValueError,
3250     "ldb context must be non-NULL");
3251   result = (PyObject *)ldb_val_to_py_object(arg1,arg2,arg3);
3252   resultobj = result;
3253   return resultobj;
3254 fail:
3255   return NULL;
3256 }
3257
3258
3259 SWIGINTERN PyObject *_wrap_new_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3260   PyObject *resultobj = 0;
3261   ldb *arg1 = (ldb *) 0 ;
3262   char *arg2 = (char *) 0 ;
3263   ldb_dn *result = 0 ;
3264   void *argp1 = 0 ;
3265   int res1 = 0 ;
3266   int res2 ;
3267   char *buf2 = 0 ;
3268   int alloc2 = 0 ;
3269   PyObject * obj0 = 0 ;
3270   PyObject * obj1 = 0 ;
3271   char *  kwnames[] = {
3272     (char *) "ldb_ctx",(char *) "str", NULL
3273   };
3274
3275   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Dn",kwnames,&obj0,&obj1)) SWIG_fail;
3276   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
3277   if (!SWIG_IsOK(res1)) {
3278     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Dn" "', argument " "1"" of type '" "ldb *""'");
3279   }
3280   arg1 = (ldb *)(argp1);
3281   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3282   if (!SWIG_IsOK(res2)) {
3283     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Dn" "', argument " "2"" of type '" "char const *""'");
3284   }
3285   arg2 = (char *)(buf2);
3286   if (arg1 == NULL)
3287   SWIG_exception(SWIG_ValueError,
3288     "ldb context must be non-NULL");
3289   result = (ldb_dn *)new_ldb_dn(arg1,(char const *)arg2);
3290   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, SWIG_POINTER_NEW |  0 );
3291   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3292   return resultobj;
3293 fail:
3294   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3295   return NULL;
3296 }
3297
3298
3299 SWIGINTERN PyObject *_wrap_delete_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3300   PyObject *resultobj = 0;
3301   ldb_dn *arg1 = (ldb_dn *) 0 ;
3302   void *argp1 = 0 ;
3303   int res1 = 0 ;
3304   PyObject *swig_obj[1] ;
3305
3306   if (!args) SWIG_fail;
3307   swig_obj[0] = args;
3308   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
3309   if (!SWIG_IsOK(res1)) {
3310     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dn" "', argument " "1"" of type '" "ldb_dn *""'");
3311   }
3312   arg1 = (ldb_dn *)(argp1);
3313   delete_ldb_dn(arg1);
3314
3315   resultobj = SWIG_Py_Void();
3316   return resultobj;
3317 fail:
3318   return NULL;
3319 }
3320
3321
3322 SWIGINTERN PyObject *_wrap_Dn_validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3323   PyObject *resultobj = 0;
3324   ldb_dn *arg1 = (ldb_dn *) 0 ;
3325   bool result;
3326   void *argp1 = 0 ;
3327   int res1 = 0 ;
3328   PyObject *swig_obj[1] ;
3329
3330   if (!args) SWIG_fail;
3331   swig_obj[0] = args;
3332   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3333   if (!SWIG_IsOK(res1)) {
3334     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_validate" "', argument " "1"" of type '" "ldb_dn *""'");
3335   }
3336   arg1 = (ldb_dn *)(argp1);
3337   result = (bool)ldb_dn_validate(arg1);
3338   resultobj = SWIG_From_bool((bool)(result));
3339   return resultobj;
3340 fail:
3341   return NULL;
3342 }
3343
3344
3345 SWIGINTERN PyObject *_wrap_Dn_get_casefold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3346   PyObject *resultobj = 0;
3347   ldb_dn *arg1 = (ldb_dn *) 0 ;
3348   char *result = 0 ;
3349   void *argp1 = 0 ;
3350   int res1 = 0 ;
3351   PyObject *swig_obj[1] ;
3352
3353   if (!args) SWIG_fail;
3354   swig_obj[0] = args;
3355   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3356   if (!SWIG_IsOK(res1)) {
3357     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_get_casefold" "', argument " "1"" of type '" "ldb_dn *""'");
3358   }
3359   arg1 = (ldb_dn *)(argp1);
3360   result = (char *)ldb_dn_get_casefold(arg1);
3361   resultobj = SWIG_FromCharPtr((const char *)result);
3362   return resultobj;
3363 fail:
3364   return NULL;
3365 }
3366
3367
3368 SWIGINTERN PyObject *_wrap_Dn___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3369   PyObject *resultobj = 0;
3370   ldb_dn *arg1 = (ldb_dn *) 0 ;
3371   char *result = 0 ;
3372   void *argp1 = 0 ;
3373   int res1 = 0 ;
3374   PyObject *swig_obj[1] ;
3375
3376   if (!args) SWIG_fail;
3377   swig_obj[0] = args;
3378   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3379   if (!SWIG_IsOK(res1)) {
3380     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___str__" "', argument " "1"" of type '" "ldb_dn *""'");
3381   }
3382   arg1 = (ldb_dn *)(argp1);
3383   result = (char *)ldb_dn_get_linearized(arg1);
3384   resultobj = SWIG_FromCharPtr((const char *)result);
3385   return resultobj;
3386 fail:
3387   return NULL;
3388 }
3389
3390
3391 SWIGINTERN PyObject *_wrap_Dn_parent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3392   PyObject *resultobj = 0;
3393   ldb_dn *arg1 = (ldb_dn *) 0 ;
3394   ldb_dn *result = 0 ;
3395   void *argp1 = 0 ;
3396   int res1 = 0 ;
3397   PyObject *swig_obj[1] ;
3398
3399   if (!args) SWIG_fail;
3400   swig_obj[0] = args;
3401   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3402   if (!SWIG_IsOK(res1)) {
3403     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_parent" "', argument " "1"" of type '" "ldb_dn *""'");
3404   }
3405   arg1 = (ldb_dn *)(argp1);
3406   result = (ldb_dn *)ldb_dn_parent(arg1);
3407   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
3408   return resultobj;
3409 fail:
3410   return NULL;
3411 }
3412
3413
3414 SWIGINTERN PyObject *_wrap_Dn___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3415   PyObject *resultobj = 0;
3416   ldb_dn *arg1 = (ldb_dn *) 0 ;
3417   ldb_dn *arg2 = (ldb_dn *) 0 ;
3418   int result;
3419   void *argp1 = 0 ;
3420   int res1 = 0 ;
3421   void *argp2 = 0 ;
3422   int res2 = 0 ;
3423   PyObject * obj0 = 0 ;
3424   PyObject * obj1 = 0 ;
3425   char *  kwnames[] = {
3426     (char *) "self",(char *) "other", NULL
3427   };
3428
3429   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
3430   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3431   if (!SWIG_IsOK(res1)) {
3432     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___cmp__" "', argument " "1"" of type '" "ldb_dn *""'");
3433   }
3434   arg1 = (ldb_dn *)(argp1);
3435   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3436   if (!SWIG_IsOK(res2)) {
3437     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___cmp__" "', argument " "2"" of type '" "ldb_dn *""'");
3438   }
3439   arg2 = (ldb_dn *)(argp2);
3440   result = (int)ldb_dn_compare(arg1,arg2);
3441   resultobj = SWIG_From_int((int)(result));
3442   return resultobj;
3443 fail:
3444   return NULL;
3445 }
3446
3447
3448 SWIGINTERN PyObject *_wrap_Dn_is_valid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3449   PyObject *resultobj = 0;
3450   ldb_dn *arg1 = (ldb_dn *) 0 ;
3451   bool result;
3452   void *argp1 = 0 ;
3453   int res1 = 0 ;
3454   PyObject *swig_obj[1] ;
3455
3456   if (!args) SWIG_fail;
3457   swig_obj[0] = args;
3458   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3459   if (!SWIG_IsOK(res1)) {
3460     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_valid" "', argument " "1"" of type '" "ldb_dn *""'");
3461   }
3462   arg1 = (ldb_dn *)(argp1);
3463   result = (bool)ldb_dn_is_valid(arg1);
3464   resultobj = SWIG_From_bool((bool)(result));
3465   return resultobj;
3466 fail:
3467   return NULL;
3468 }
3469
3470
3471 SWIGINTERN PyObject *_wrap_Dn_is_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3472   PyObject *resultobj = 0;
3473   ldb_dn *arg1 = (ldb_dn *) 0 ;
3474   bool result;
3475   void *argp1 = 0 ;
3476   int res1 = 0 ;
3477   PyObject *swig_obj[1] ;
3478
3479   if (!args) SWIG_fail;
3480   swig_obj[0] = args;
3481   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3482   if (!SWIG_IsOK(res1)) {
3483     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_special" "', argument " "1"" of type '" "ldb_dn *""'");
3484   }
3485   arg1 = (ldb_dn *)(argp1);
3486   result = (bool)ldb_dn_is_special(arg1);
3487   resultobj = SWIG_From_bool((bool)(result));
3488   return resultobj;
3489 fail:
3490   return NULL;
3491 }
3492
3493
3494 SWIGINTERN PyObject *_wrap_Dn_is_null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3495   PyObject *resultobj = 0;
3496   ldb_dn *arg1 = (ldb_dn *) 0 ;
3497   bool result;
3498   void *argp1 = 0 ;
3499   int res1 = 0 ;
3500   PyObject *swig_obj[1] ;
3501
3502   if (!args) SWIG_fail;
3503   swig_obj[0] = args;
3504   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3505   if (!SWIG_IsOK(res1)) {
3506     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_null" "', argument " "1"" of type '" "ldb_dn *""'");
3507   }
3508   arg1 = (ldb_dn *)(argp1);
3509   result = (bool)ldb_dn_is_null(arg1);
3510   resultobj = SWIG_From_bool((bool)(result));
3511   return resultobj;
3512 fail:
3513   return NULL;
3514 }
3515
3516
3517 SWIGINTERN PyObject *_wrap_Dn_check_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3518   PyObject *resultobj = 0;
3519   ldb_dn *arg1 = (ldb_dn *) 0 ;
3520   char *arg2 = (char *) 0 ;
3521   bool result;
3522   void *argp1 = 0 ;
3523   int res1 = 0 ;
3524   int res2 ;
3525   char *buf2 = 0 ;
3526   int alloc2 = 0 ;
3527   PyObject * obj0 = 0 ;
3528   PyObject * obj1 = 0 ;
3529   char *  kwnames[] = {
3530     (char *) "self",(char *) "name", NULL
3531   };
3532
3533   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_check_special",kwnames,&obj0,&obj1)) SWIG_fail;
3534   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3535   if (!SWIG_IsOK(res1)) {
3536     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_check_special" "', argument " "1"" of type '" "ldb_dn *""'");
3537   }
3538   arg1 = (ldb_dn *)(argp1);
3539   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3540   if (!SWIG_IsOK(res2)) {
3541     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_check_special" "', argument " "2"" of type '" "char const *""'");
3542   }
3543   arg2 = (char *)(buf2);
3544   result = (bool)ldb_dn_check_special(arg1,(char const *)arg2);
3545   resultobj = SWIG_From_bool((bool)(result));
3546   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3547   return resultobj;
3548 fail:
3549   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3550   return NULL;
3551 }
3552
3553
3554 SWIGINTERN PyObject *_wrap_Dn___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3555   PyObject *resultobj = 0;
3556   ldb_dn *arg1 = (ldb_dn *) 0 ;
3557   int result;
3558   void *argp1 = 0 ;
3559   int res1 = 0 ;
3560   PyObject *swig_obj[1] ;
3561
3562   if (!args) SWIG_fail;
3563   swig_obj[0] = args;
3564   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3565   if (!SWIG_IsOK(res1)) {
3566     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___len__" "', argument " "1"" of type '" "ldb_dn *""'");
3567   }
3568   arg1 = (ldb_dn *)(argp1);
3569   result = (int)ldb_dn_get_comp_num(arg1);
3570   resultobj = SWIG_From_int((int)(result));
3571   return resultobj;
3572 fail:
3573   return NULL;
3574 }
3575
3576
3577 SWIGINTERN PyObject *_wrap_Dn_add_child(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3578   PyObject *resultobj = 0;
3579   ldb_dn *arg1 = (ldb_dn *) 0 ;
3580   ldb_dn *arg2 = (ldb_dn *) 0 ;
3581   bool result;
3582   void *argp1 = 0 ;
3583   int res1 = 0 ;
3584   void *argp2 = 0 ;
3585   int res2 = 0 ;
3586   PyObject * obj0 = 0 ;
3587   PyObject * obj1 = 0 ;
3588   char *  kwnames[] = {
3589     (char *) "self",(char *) "child", NULL
3590   };
3591
3592   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_child",kwnames,&obj0,&obj1)) SWIG_fail;
3593   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3594   if (!SWIG_IsOK(res1)) {
3595     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_child" "', argument " "1"" of type '" "ldb_dn *""'");
3596   }
3597   arg1 = (ldb_dn *)(argp1);
3598   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3599   if (!SWIG_IsOK(res2)) {
3600     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_child" "', argument " "2"" of type '" "ldb_dn *""'");
3601   }
3602   arg2 = (ldb_dn *)(argp2);
3603   result = (bool)ldb_dn_add_child(arg1,arg2);
3604   resultobj = SWIG_From_bool((bool)(result));
3605   return resultobj;
3606 fail:
3607   return NULL;
3608 }
3609
3610
3611 SWIGINTERN PyObject *_wrap_Dn_add_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3612   PyObject *resultobj = 0;
3613   ldb_dn *arg1 = (ldb_dn *) 0 ;
3614   ldb_dn *arg2 = (ldb_dn *) 0 ;
3615   bool result;
3616   void *argp1 = 0 ;
3617   int res1 = 0 ;
3618   void *argp2 = 0 ;
3619   int res2 = 0 ;
3620   PyObject * obj0 = 0 ;
3621   PyObject * obj1 = 0 ;
3622   char *  kwnames[] = {
3623     (char *) "self",(char *) "base", NULL
3624   };
3625
3626   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_base",kwnames,&obj0,&obj1)) SWIG_fail;
3627   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3628   if (!SWIG_IsOK(res1)) {
3629     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_base" "', argument " "1"" of type '" "ldb_dn *""'");
3630   }
3631   arg1 = (ldb_dn *)(argp1);
3632   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3633   if (!SWIG_IsOK(res2)) {
3634     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_base" "', argument " "2"" of type '" "ldb_dn *""'");
3635   }
3636   arg2 = (ldb_dn *)(argp2);
3637   result = (bool)ldb_dn_add_base(arg1,arg2);
3638   resultobj = SWIG_From_bool((bool)(result));
3639   return resultobj;
3640 fail:
3641   return NULL;
3642 }
3643
3644
3645 SWIGINTERN PyObject *_wrap_Dn_canonical_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3646   PyObject *resultobj = 0;
3647   ldb_dn *arg1 = (ldb_dn *) 0 ;
3648   char *result = 0 ;
3649   void *argp1 = 0 ;
3650   int res1 = 0 ;
3651   PyObject *swig_obj[1] ;
3652
3653   if (!args) SWIG_fail;
3654   swig_obj[0] = args;
3655   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3656   if (!SWIG_IsOK(res1)) {
3657     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_str" "', argument " "1"" of type '" "ldb_dn *""'");
3658   }
3659   arg1 = (ldb_dn *)(argp1);
3660   result = (char *)ldb_dn_canonical_str(arg1);
3661   resultobj = SWIG_FromCharPtr((const char *)result);
3662   return resultobj;
3663 fail:
3664   return NULL;
3665 }
3666
3667
3668 SWIGINTERN PyObject *_wrap_Dn_canonical_ex_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3669   PyObject *resultobj = 0;
3670   ldb_dn *arg1 = (ldb_dn *) 0 ;
3671   char *result = 0 ;
3672   void *argp1 = 0 ;
3673   int res1 = 0 ;
3674   PyObject *swig_obj[1] ;
3675
3676   if (!args) SWIG_fail;
3677   swig_obj[0] = args;
3678   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3679   if (!SWIG_IsOK(res1)) {
3680     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_ex_str" "', argument " "1"" of type '" "ldb_dn *""'");
3681   }
3682   arg1 = (ldb_dn *)(argp1);
3683   result = (char *)ldb_dn_canonical_ex_str(arg1);
3684   resultobj = SWIG_FromCharPtr((const char *)result);
3685   return resultobj;
3686 fail:
3687   return NULL;
3688 }
3689
3690
3691 SWIGINTERN PyObject *_wrap_Dn___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3692   PyObject *resultobj = 0;
3693   ldb_dn *arg1 = (ldb_dn *) 0 ;
3694   ldb_dn *arg2 = (ldb_dn *) 0 ;
3695   ldb_dn *result = 0 ;
3696   void *argp1 = 0 ;
3697   int res1 = 0 ;
3698   void *argp2 = 0 ;
3699   int res2 = 0 ;
3700   PyObject * obj0 = 0 ;
3701   PyObject * obj1 = 0 ;
3702   char *  kwnames[] = {
3703     (char *) "self",(char *) "other", NULL
3704   };
3705
3706   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___add__",kwnames,&obj0,&obj1)) SWIG_fail;
3707   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3708   if (!SWIG_IsOK(res1)) {
3709     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___add__" "', argument " "1"" of type '" "ldb_dn *""'");
3710   }
3711   arg1 = (ldb_dn *)(argp1);
3712   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3713   if (!SWIG_IsOK(res2)) {
3714     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___add__" "', argument " "2"" of type '" "ldb_dn *""'");
3715   }
3716   arg2 = (ldb_dn *)(argp2);
3717   result = (ldb_dn *)ldb_dn___add__(arg1,arg2);
3718   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
3719   return resultobj;
3720 fail:
3721   return NULL;
3722 }
3723
3724
3725 SWIGINTERN PyObject *Dn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3726   PyObject *obj;
3727   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3728   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_dn, SWIG_NewClientData(obj));
3729   return SWIG_Py_Void();
3730 }
3731
3732 SWIGINTERN PyObject *Dn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3733   return SWIG_Python_InitShadowInstance(args);
3734 }
3735
3736 SWIGINTERN PyObject *_wrap_ldb_msg_element___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3737   PyObject *resultobj = 0;
3738   ldb_msg_element *arg1 = (ldb_msg_element *) 0 ;
3739   PyObject *result = 0 ;
3740   void *argp1 = 0 ;
3741   int res1 = 0 ;
3742   PyObject *swig_obj[1] ;
3743
3744   if (!args) SWIG_fail;
3745   swig_obj[0] = args;
3746   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3747   if (!SWIG_IsOK(res1)) {
3748     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_element___iter__" "', argument " "1"" of type '" "ldb_msg_element *""'");
3749   }
3750   arg1 = (ldb_msg_element *)(argp1);
3751   result = (PyObject *)ldb_msg_element___iter__(arg1);
3752   resultobj = result;
3753   return resultobj;
3754 fail:
3755   return NULL;
3756 }
3757
3758
3759 SWIGINTERN PyObject *_wrap_ldb_msg_element___set__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3760   PyObject *resultobj = 0;
3761   ldb_msg_element *arg1 = (ldb_msg_element *) 0 ;
3762   PyObject *result = 0 ;
3763   void *argp1 = 0 ;
3764   int res1 = 0 ;
3765   PyObject *swig_obj[1] ;
3766
3767   if (!args) SWIG_fail;
3768   swig_obj[0] = args;
3769   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3770   if (!SWIG_IsOK(res1)) {
3771     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_element___set__" "', argument " "1"" of type '" "ldb_msg_element *""'");
3772   }
3773   arg1 = (ldb_msg_element *)(argp1);
3774   result = (PyObject *)ldb_msg_element___set__(arg1);
3775   resultobj = result;
3776   return resultobj;
3777 fail:
3778   return NULL;
3779 }
3780
3781
3782 SWIGINTERN PyObject *_wrap_new_MessageElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3783   PyObject *resultobj = 0;
3784   PyObject *arg1 = (PyObject *) 0 ;
3785   int arg2 = (int) 0 ;
3786   char *arg3 = (char *) NULL ;
3787   ldb_msg_element *result = 0 ;
3788   int val2 ;
3789   int ecode2 = 0 ;
3790   int res3 ;
3791   char *buf3 = 0 ;
3792   int alloc3 = 0 ;
3793   PyObject * obj0 = 0 ;
3794   PyObject * obj1 = 0 ;
3795   PyObject * obj2 = 0 ;
3796   char *  kwnames[] = {
3797     (char *) "set_obj",(char *) "flags",(char *) "name", NULL
3798   };
3799
3800   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_MessageElement",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3801   arg1 = obj0;
3802   if (obj1) {
3803     ecode2 = SWIG_AsVal_int(obj1, &val2);
3804     if (!SWIG_IsOK(ecode2)) {
3805       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MessageElement" "', argument " "2"" of type '" "int""'");
3806     }
3807     arg2 = (int)(val2);
3808   }
3809   if (obj2) {
3810     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3811     if (!SWIG_IsOK(res3)) {
3812       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MessageElement" "', argument " "3"" of type '" "char const *""'");
3813     }
3814     arg3 = (char *)(buf3);
3815   }
3816   result = (ldb_msg_element *)new_ldb_msg_element(arg1,arg2,(char const *)arg3);
3817   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message_element, SWIG_POINTER_OWN |  0 );
3818   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3819   return resultobj;
3820 fail:
3821   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3822   return NULL;
3823 }
3824
3825
3826 SWIGINTERN PyObject *_wrap_ldb_msg_element___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3827   PyObject *resultobj = 0;
3828   ldb_msg_element *arg1 = (ldb_msg_element *) 0 ;
3829   int result;
3830   void *argp1 = 0 ;
3831   int res1 = 0 ;
3832   PyObject *swig_obj[1] ;
3833
3834   if (!args) SWIG_fail;
3835   swig_obj[0] = args;
3836   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3837   if (!SWIG_IsOK(res1)) {
3838     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_element___len__" "', argument " "1"" of type '" "ldb_msg_element *""'");
3839   }
3840   arg1 = (ldb_msg_element *)(argp1);
3841   result = (int)ldb_msg_element___len__(arg1);
3842   resultobj = SWIG_From_int((int)(result));
3843   return resultobj;
3844 fail:
3845   return NULL;
3846 }
3847
3848
3849 SWIGINTERN PyObject *_wrap_ldb_msg_element_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3850   PyObject *resultobj = 0;
3851   ldb_msg_element *arg1 = (ldb_msg_element *) 0 ;
3852   int arg2 ;
3853   PyObject *result = 0 ;
3854   void *argp1 = 0 ;
3855   int res1 = 0 ;
3856   int val2 ;
3857   int ecode2 = 0 ;
3858   PyObject * obj0 = 0 ;
3859   PyObject * obj1 = 0 ;
3860   char *  kwnames[] = {
3861     (char *) "self",(char *) "i", NULL
3862   };
3863
3864   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_msg_element_get",kwnames,&obj0,&obj1)) SWIG_fail;
3865   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3866   if (!SWIG_IsOK(res1)) {
3867     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_element_get" "', argument " "1"" of type '" "ldb_msg_element *""'");
3868   }
3869   arg1 = (ldb_msg_element *)(argp1);
3870   ecode2 = SWIG_AsVal_int(obj1, &val2);
3871   if (!SWIG_IsOK(ecode2)) {
3872     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ldb_msg_element_get" "', argument " "2"" of type '" "int""'");
3873   }
3874   arg2 = (int)(val2);
3875   result = (PyObject *)ldb_msg_element_get(arg1,arg2);
3876   resultobj = result;
3877   return resultobj;
3878 fail:
3879   return NULL;
3880 }
3881
3882
3883 SWIGINTERN PyObject *_wrap_delete_ldb_msg_element(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3884   PyObject *resultobj = 0;
3885   ldb_msg_element *arg1 = (ldb_msg_element *) 0 ;
3886   void *argp1 = 0 ;
3887   int res1 = 0 ;
3888   PyObject *swig_obj[1] ;
3889
3890   if (!args) SWIG_fail;
3891   swig_obj[0] = args;
3892   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, SWIG_POINTER_DISOWN |  0 );
3893   if (!SWIG_IsOK(res1)) {
3894     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ldb_msg_element" "', argument " "1"" of type '" "ldb_msg_element *""'");
3895   }
3896   arg1 = (ldb_msg_element *)(argp1);
3897   delete_ldb_msg_element(arg1);
3898
3899   resultobj = SWIG_Py_Void();
3900   return resultobj;
3901 fail:
3902   return NULL;
3903 }
3904
3905
3906 SWIGINTERN PyObject *_wrap_ldb_msg_element___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3907   PyObject *resultobj = 0;
3908   ldb_msg_element *arg1 = (ldb_msg_element *) 0 ;
3909   ldb_msg_element *arg2 = (ldb_msg_element *) 0 ;
3910   int result;
3911   void *argp1 = 0 ;
3912   int res1 = 0 ;
3913   void *argp2 = 0 ;
3914   int res2 = 0 ;
3915   PyObject * obj0 = 0 ;
3916   PyObject * obj1 = 0 ;
3917   char *  kwnames[] = {
3918     (char *) "self",(char *)"arg2", NULL
3919   };
3920
3921   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_msg_element___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
3922   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3923   if (!SWIG_IsOK(res1)) {
3924     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_element___cmp__" "', argument " "1"" of type '" "ldb_msg_element *""'");
3925   }
3926   arg1 = (ldb_msg_element *)(argp1);
3927   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3928   if (!SWIG_IsOK(res2)) {
3929     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_msg_element___cmp__" "', argument " "2"" of type '" "ldb_msg_element *""'");
3930   }
3931   arg2 = (ldb_msg_element *)(argp2);
3932   result = (int)ldb_msg_element_compare(arg1,arg2);
3933   resultobj = SWIG_From_int((int)(result));
3934   return resultobj;
3935 fail:
3936   return NULL;
3937 }
3938
3939
3940 SWIGINTERN PyObject *ldb_msg_element_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3941   PyObject *obj;
3942   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3943   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message_element, SWIG_NewClientData(obj));
3944   return SWIG_Py_Void();
3945 }
3946
3947 SWIGINTERN PyObject *_wrap_ldb_msg_list_elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3948   PyObject *resultobj = 0;
3949   ldb_msg *arg1 = (ldb_msg *) 0 ;
3950   PyObject *result = 0 ;
3951   void *argp1 = 0 ;
3952   int res1 = 0 ;
3953   PyObject * obj0 = 0 ;
3954   char *  kwnames[] = {
3955     (char *) "msg", NULL
3956   };
3957
3958   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_msg_list_elements",kwnames,&obj0)) SWIG_fail;
3959   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
3960   if (!SWIG_IsOK(res1)) {
3961     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_list_elements" "', argument " "1"" of type '" "ldb_msg *""'");
3962   }
3963   arg1 = (ldb_msg *)(argp1);
3964   if (arg1 == NULL)
3965   SWIG_exception(SWIG_ValueError,
3966     "Message can not be None");
3967   result = (PyObject *)ldb_msg_list_elements(arg1);
3968   resultobj = result;
3969   return resultobj;
3970 fail:
3971   return NULL;
3972 }
3973
3974
3975 SWIGINTERN PyObject *_wrap_Message_dn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3976   PyObject *resultobj = 0;
3977   ldb_msg *arg1 = (ldb_msg *) 0 ;
3978   ldb_dn *arg2 = (ldb_dn *) 0 ;
3979   void *argp1 = 0 ;
3980   int res1 = 0 ;
3981   void *argp2 = 0 ;
3982   int res2 = 0 ;
3983   PyObject *swig_obj[2] ;
3984
3985   if (!SWIG_Python_UnpackTuple(args,"Message_dn_set",2,2,swig_obj)) SWIG_fail;
3986   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
3987   if (!SWIG_IsOK(res1)) {
3988     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_set" "', argument " "1"" of type '" "ldb_msg *""'");
3989   }
3990   arg1 = (ldb_msg *)(argp1);
3991   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
3992   if (!SWIG_IsOK(res2)) {
3993     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_dn_set" "', argument " "2"" of type '" "ldb_dn *""'");
3994   }
3995   arg2 = (ldb_dn *)(argp2);
3996   if (arg1 == NULL)
3997   SWIG_exception(SWIG_ValueError,
3998     "Message can not be None");
3999   if (arg1) (arg1)->dn = arg2;
4000
4001   resultobj = SWIG_Py_Void();
4002   return resultobj;
4003 fail:
4004   return NULL;
4005 }
4006
4007
4008 SWIGINTERN PyObject *_wrap_Message_dn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4009   PyObject *resultobj = 0;
4010   ldb_msg *arg1 = (ldb_msg *) 0 ;
4011   ldb_dn *result = 0 ;
4012   void *argp1 = 0 ;
4013   int res1 = 0 ;
4014   PyObject *swig_obj[1] ;
4015
4016   if (!args) SWIG_fail;
4017   swig_obj[0] = args;
4018   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4019   if (!SWIG_IsOK(res1)) {
4020     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_get" "', argument " "1"" of type '" "ldb_msg *""'");
4021   }
4022   arg1 = (ldb_msg *)(argp1);
4023   if (arg1 == NULL)
4024   SWIG_exception(SWIG_ValueError,
4025     "Message can not be None");
4026   result = (ldb_dn *) ((arg1)->dn);
4027   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4028   return resultobj;
4029 fail:
4030   return NULL;
4031 }
4032
4033
4034 SWIGINTERN PyObject *_wrap_new_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4035   PyObject *resultobj = 0;
4036   ldb_dn *arg1 = (ldb_dn *) NULL ;
4037   ldb_msg *result = 0 ;
4038   void *argp1 = 0 ;
4039   int res1 = 0 ;
4040   PyObject * obj0 = 0 ;
4041   char *  kwnames[] = {
4042     (char *) "dn", NULL
4043   };
4044
4045   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Message",kwnames,&obj0)) SWIG_fail;
4046   if (obj0) {
4047     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4048     if (!SWIG_IsOK(res1)) {
4049       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "ldb_dn *""'");
4050     }
4051     arg1 = (ldb_dn *)(argp1);
4052   }
4053   result = (ldb_msg *)new_ldb_msg(arg1);
4054   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message, SWIG_POINTER_NEW |  0 );
4055   return resultobj;
4056 fail:
4057   return NULL;
4058 }
4059
4060
4061 SWIGINTERN PyObject *_wrap_delete_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4062   PyObject *resultobj = 0;
4063   ldb_msg *arg1 = (ldb_msg *) 0 ;
4064   void *argp1 = 0 ;
4065   int res1 = 0 ;
4066   PyObject *swig_obj[1] ;
4067
4068   if (!args) SWIG_fail;
4069   swig_obj[0] = args;
4070   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, SWIG_POINTER_DISOWN |  0 );
4071   if (!SWIG_IsOK(res1)) {
4072     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Message" "', argument " "1"" of type '" "ldb_msg *""'");
4073   }
4074   arg1 = (ldb_msg *)(argp1);
4075   if (arg1 == NULL)
4076   SWIG_exception(SWIG_ValueError,
4077     "Message can not be None");
4078   delete_ldb_msg(arg1);
4079
4080   resultobj = SWIG_Py_Void();
4081   return resultobj;
4082 fail:
4083   return NULL;
4084 }
4085
4086
4087 SWIGINTERN PyObject *_wrap_Message___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4088   PyObject *resultobj = 0;
4089   ldb_msg *arg1 = (ldb_msg *) 0 ;
4090   char *arg2 = (char *) 0 ;
4091   ldb_msg_element *result = 0 ;
4092   void *argp1 = 0 ;
4093   int res1 = 0 ;
4094   int res2 ;
4095   char *buf2 = 0 ;
4096   int alloc2 = 0 ;
4097   PyObject * obj0 = 0 ;
4098   PyObject * obj1 = 0 ;
4099   char *  kwnames[] = {
4100     (char *) "self",(char *) "name", NULL
4101   };
4102
4103   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message___getitem__",kwnames,&obj0,&obj1)) SWIG_fail;
4104   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4105   if (!SWIG_IsOK(res1)) {
4106     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___getitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4107   }
4108   arg1 = (ldb_msg *)(argp1);
4109   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4110   if (!SWIG_IsOK(res2)) {
4111     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___getitem__" "', argument " "2"" of type '" "char const *""'");
4112   }
4113   arg2 = (char *)(buf2);
4114   if (arg1 == NULL)
4115   SWIG_exception(SWIG_ValueError,
4116     "Message can not be None");
4117   result = (ldb_msg_element *)ldb_msg_find_element(arg1,(char const *)arg2);
4118   {
4119     if (result == NULL)
4120     PyErr_SetString(PyExc_KeyError, "no such element");
4121     else
4122     resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_ldb_message_element, 0);
4123   }
4124   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4125   return resultobj;
4126 fail:
4127   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4128   return NULL;
4129 }
4130
4131
4132 SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4133   PyObject *resultobj = 0;
4134   ldb_msg *arg1 = (ldb_msg *) 0 ;
4135   char *arg2 = (char *) 0 ;
4136   ldb_msg_element *arg3 = (ldb_msg_element *) 0 ;
4137   void *argp1 = 0 ;
4138   int res1 = 0 ;
4139   int res2 ;
4140   char *buf2 = 0 ;
4141   int alloc2 = 0 ;
4142   void *argp3 = 0 ;
4143   int res3 = 0 ;
4144
4145   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
4146   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4147   if (!SWIG_IsOK(res1)) {
4148     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4149   }
4150   arg1 = (ldb_msg *)(argp1);
4151   res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
4152   if (!SWIG_IsOK(res2)) {
4153     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
4154   }
4155   arg2 = (char *)(buf2);
4156   res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4157   if (!SWIG_IsOK(res3)) {
4158     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message___setitem__" "', argument " "3"" of type '" "ldb_msg_element *""'");
4159   }
4160   arg3 = (ldb_msg_element *)(argp3);
4161   if (arg1 == NULL)
4162   SWIG_exception(SWIG_ValueError,
4163     "Message can not be None");
4164   ldb_msg___setitem____SWIG_0(arg1,(char const *)arg2,arg3);
4165   resultobj = SWIG_Py_Void();
4166   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4167   return resultobj;
4168 fail:
4169   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4170   return NULL;
4171 }
4172
4173
4174 SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4175   PyObject *resultobj = 0;
4176   ldb_msg *arg1 = (ldb_msg *) 0 ;
4177   char *arg2 = (char *) 0 ;
4178   PyObject *arg3 = (PyObject *) 0 ;
4179   void *argp1 = 0 ;
4180   int res1 = 0 ;
4181   int res2 ;
4182   char *buf2 = 0 ;
4183   int alloc2 = 0 ;
4184
4185   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
4186   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4187   if (!SWIG_IsOK(res1)) {
4188     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4189   }
4190   arg1 = (ldb_msg *)(argp1);
4191   res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
4192   if (!SWIG_IsOK(res2)) {
4193     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
4194   }
4195   arg2 = (char *)(buf2);
4196   arg3 = swig_obj[2];
4197   if (arg1 == NULL)
4198   SWIG_exception(SWIG_ValueError,
4199     "Message can not be None");
4200   ldb_msg___setitem____SWIG_1(arg1,(char const *)arg2,arg3);
4201   resultobj = SWIG_Py_Void();
4202   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4203   return resultobj;
4204 fail:
4205   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4206   return NULL;
4207 }
4208
4209
4210 SWIGINTERN PyObject *_wrap_Message___setitem__(PyObject *self, PyObject *args) {
4211   int argc;
4212   PyObject *argv[4];
4213
4214   if (!(argc = SWIG_Python_UnpackTuple(args,"Message___setitem__",0,3,argv))) SWIG_fail;
4215   --argc;
4216   if (argc == 3) {
4217     int _v = 0;
4218     {
4219       void *vptr = 0;
4220       int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ldb_message_element, 0);
4221       _v = SWIG_CheckState(res);
4222     }
4223     if (!_v) goto check_1;
4224     return _wrap_Message___setitem____SWIG_0(self, argc, argv);
4225   }
4226 check_1:
4227
4228   if (argc == 3) {
4229     return _wrap_Message___setitem____SWIG_1(self, argc, argv);
4230   }
4231
4232 fail:
4233   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message___setitem__'.\n  Possible C/C++ prototypes are:\n""    __setitem__(ldb_msg *,char const *,ldb_msg_element *)\n""    __setitem__(ldb_msg *,char const *,PyObject *)\n");
4234   return NULL;
4235 }
4236
4237
4238 SWIGINTERN PyObject *_wrap_Message___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4239   PyObject *resultobj = 0;
4240   ldb_msg *arg1 = (ldb_msg *) 0 ;
4241   unsigned int result;
4242   void *argp1 = 0 ;
4243   int res1 = 0 ;
4244   PyObject *swig_obj[1] ;
4245
4246   if (!args) SWIG_fail;
4247   swig_obj[0] = args;
4248   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4249   if (!SWIG_IsOK(res1)) {
4250     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___len__" "', argument " "1"" of type '" "ldb_msg *""'");
4251   }
4252   arg1 = (ldb_msg *)(argp1);
4253   if (arg1 == NULL)
4254   SWIG_exception(SWIG_ValueError,
4255     "Message can not be None");
4256   result = (unsigned int)ldb_msg___len__(arg1);
4257   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4258   return resultobj;
4259 fail:
4260   return NULL;
4261 }
4262
4263
4264 SWIGINTERN PyObject *_wrap_Message_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4265   PyObject *resultobj = 0;
4266   ldb_msg *arg1 = (ldb_msg *) 0 ;
4267   PyObject *result = 0 ;
4268   void *argp1 = 0 ;
4269   int res1 = 0 ;
4270   PyObject *swig_obj[1] ;
4271
4272   if (!args) SWIG_fail;
4273   swig_obj[0] = args;
4274   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4275   if (!SWIG_IsOK(res1)) {
4276     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_keys" "', argument " "1"" of type '" "ldb_msg *""'");
4277   }
4278   arg1 = (ldb_msg *)(argp1);
4279   if (arg1 == NULL)
4280   SWIG_exception(SWIG_ValueError,
4281     "Message can not be None");
4282   result = (PyObject *)ldb_msg_keys(arg1);
4283   resultobj = result;
4284   return resultobj;
4285 fail:
4286   return NULL;
4287 }
4288
4289
4290 SWIGINTERN PyObject *_wrap_Message___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4291   PyObject *resultobj = 0;
4292   ldb_msg *arg1 = (ldb_msg *) 0 ;
4293   PyObject *result = 0 ;
4294   void *argp1 = 0 ;
4295   int res1 = 0 ;
4296   PyObject *swig_obj[1] ;
4297
4298   if (!args) SWIG_fail;
4299   swig_obj[0] = args;
4300   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4301   if (!SWIG_IsOK(res1)) {
4302     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___iter__" "', argument " "1"" of type '" "ldb_msg *""'");
4303   }
4304   arg1 = (ldb_msg *)(argp1);
4305   if (arg1 == NULL)
4306   SWIG_exception(SWIG_ValueError,
4307     "Message can not be None");
4308   result = (PyObject *)ldb_msg___iter__(arg1);
4309   resultobj = result;
4310   return resultobj;
4311 fail:
4312   return NULL;
4313 }
4314
4315
4316 SWIGINTERN PyObject *_wrap_Message___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4317   PyObject *resultobj = 0;
4318   ldb_msg *arg1 = (ldb_msg *) 0 ;
4319   char *arg2 = (char *) 0 ;
4320   void *argp1 = 0 ;
4321   int res1 = 0 ;
4322   int res2 ;
4323   char *buf2 = 0 ;
4324   int alloc2 = 0 ;
4325   PyObject * obj0 = 0 ;
4326   PyObject * obj1 = 0 ;
4327   char *  kwnames[] = {
4328     (char *) "self",(char *) "name", NULL
4329   };
4330
4331   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message___delitem__",kwnames,&obj0,&obj1)) SWIG_fail;
4332   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4333   if (!SWIG_IsOK(res1)) {
4334     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___delitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4335   }
4336   arg1 = (ldb_msg *)(argp1);
4337   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4338   if (!SWIG_IsOK(res2)) {
4339     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___delitem__" "', argument " "2"" of type '" "char const *""'");
4340   }
4341   arg2 = (char *)(buf2);
4342   if (arg1 == NULL)
4343   SWIG_exception(SWIG_ValueError,
4344     "Message can not be None");
4345   ldb_msg_remove_attr(arg1,(char const *)arg2);
4346   resultobj = SWIG_Py_Void();
4347   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4348   return resultobj;
4349 fail:
4350   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4351   return NULL;
4352 }
4353
4354
4355 SWIGINTERN PyObject *Message_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4356   PyObject *obj;
4357   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4358   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message, SWIG_NewClientData(obj));
4359   return SWIG_Py_Void();
4360 }
4361
4362 SWIGINTERN PyObject *Message_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4363   return SWIG_Python_InitShadowInstance(args);
4364 }
4365
4366 SWIGINTERN PyObject *_wrap_ldb_ldif_to_pyobject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4367   PyObject *resultobj = 0;
4368   ldb_ldif *arg1 = (ldb_ldif *) 0 ;
4369   PyObject *result = 0 ;
4370   void *argp1 = 0 ;
4371   int res1 = 0 ;
4372   PyObject * obj0 = 0 ;
4373   char *  kwnames[] = {
4374     (char *) "ldif", NULL
4375   };
4376
4377   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_ldif_to_pyobject",kwnames,&obj0)) SWIG_fail;
4378   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_ldif, 0 |  0 );
4379   if (!SWIG_IsOK(res1)) {
4380     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_ldif_to_pyobject" "', argument " "1"" of type '" "ldb_ldif *""'");
4381   }
4382   arg1 = (ldb_ldif *)(argp1);
4383   result = (PyObject *)ldb_ldif_to_pyobject(arg1);
4384   resultobj = result;
4385   return resultobj;
4386 fail:
4387   return NULL;
4388 }
4389
4390
4391 SWIGINTERN PyObject *_wrap_new_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4392   PyObject *resultobj = 0;
4393   ldb *result = 0 ;
4394
4395   if (!SWIG_Python_UnpackTuple(args,"new_Ldb",0,0,0)) SWIG_fail;
4396   result = (ldb *)new_ldb();
4397   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_context, SWIG_POINTER_NEW |  0 );
4398   return resultobj;
4399 fail:
4400   return NULL;
4401 }
4402
4403
4404 SWIGINTERN PyObject *_wrap_Ldb_connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4405   PyObject *resultobj = 0;
4406   ldb *arg1 = (ldb *) 0 ;
4407   char *arg2 = (char *) 0 ;
4408   unsigned int arg3 = (unsigned int) 0 ;
4409   char **arg4 = (char **) (char **)NULL ;
4410   ldb_error result;
4411   void *argp1 = 0 ;
4412   int res1 = 0 ;
4413   int res2 ;
4414   char *buf2 = 0 ;
4415   int alloc2 = 0 ;
4416   unsigned int val3 ;
4417   int ecode3 = 0 ;
4418   void *argp4 = 0 ;
4419   int res4 = 0 ;
4420   PyObject * obj0 = 0 ;
4421   PyObject * obj1 = 0 ;
4422   PyObject * obj2 = 0 ;
4423   PyObject * obj3 = 0 ;
4424   char *  kwnames[] = {
4425     (char *) "self",(char *) "url",(char *) "flags",(char *) "options", NULL
4426   };
4427
4428   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Ldb_connect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4429   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4430   if (!SWIG_IsOK(res1)) {
4431     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_connect" "', argument " "1"" of type '" "ldb *""'");
4432   }
4433   arg1 = (ldb *)(argp1);
4434   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4435   if (!SWIG_IsOK(res2)) {
4436     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_connect" "', argument " "2"" of type '" "char const *""'");
4437   }
4438   arg2 = (char *)(buf2);
4439   if (obj2) {
4440     ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
4441     if (!SWIG_IsOK(ecode3)) {
4442       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_connect" "', argument " "3"" of type '" "unsigned int""'");
4443     }
4444     arg3 = (unsigned int)(val3);
4445   }
4446   if (obj3) {
4447     res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_char, 0 |  0 );
4448     if (!SWIG_IsOK(res4)) {
4449       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_connect" "', argument " "4"" of type '" "char const *[]""'");
4450     }
4451     arg4 = (char **)(argp4);
4452   }
4453   if (arg1 == NULL)
4454   SWIG_exception(SWIG_ValueError,
4455     "ldb context must be non-NULL");
4456   result = ldb_connect(arg1,(char const *)arg2,arg3,(char const *(*))arg4);
4457   if (result != 0) {
4458     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
4459     SWIG_fail;
4460   }
4461   resultobj = Py_None;
4462   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4463   return resultobj;
4464 fail:
4465   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4466   return NULL;
4467 }
4468
4469
4470 SWIGINTERN PyObject *_wrap_delete_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4471   PyObject *resultobj = 0;
4472   ldb *arg1 = (ldb *) 0 ;
4473   void *argp1 = 0 ;
4474   int res1 = 0 ;
4475   PyObject *swig_obj[1] ;
4476
4477   if (!args) SWIG_fail;
4478   swig_obj[0] = args;
4479   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, SWIG_POINTER_DISOWN |  0 );
4480   if (!SWIG_IsOK(res1)) {
4481     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ldb" "', argument " "1"" of type '" "ldb *""'");
4482   }
4483   arg1 = (ldb *)(argp1);
4484   if (arg1 == NULL)
4485   SWIG_exception(SWIG_ValueError,
4486     "ldb context must be non-NULL");
4487   delete_ldb(arg1);
4488
4489   resultobj = SWIG_Py_Void();
4490   return resultobj;
4491 fail:
4492   return NULL;
4493 }
4494
4495
4496 SWIGINTERN PyObject *_wrap_Ldb_search_ex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4497   PyObject *resultobj = 0;
4498   ldb *arg1 = (ldb *) 0 ;
4499   TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
4500   ldb_dn *arg3 = (ldb_dn *) NULL ;
4501   enum ldb_scope arg4 = (enum ldb_scope) LDB_SCOPE_DEFAULT ;
4502   char *arg5 = (char *) NULL ;
4503   char **arg6 = (char **) NULL ;
4504   struct ldb_control **arg7 = (struct ldb_control **) NULL ;
4505   struct ldb_result **arg8 = (struct ldb_result **) 0 ;
4506   ldb_error result;
4507   void *argp1 = 0 ;
4508   int res1 = 0 ;
4509   int val4 ;
4510   int ecode4 = 0 ;
4511   int res5 ;
4512   char *buf5 = 0 ;
4513   int alloc5 = 0 ;
4514   void *argp7 = 0 ;
4515   int res7 = 0 ;
4516   struct ldb_result *temp_ldb_result8 ;
4517   int i8 ;
4518   PyObject * obj0 = 0 ;
4519   PyObject * obj1 = 0 ;
4520   PyObject * obj2 = 0 ;
4521   PyObject * obj3 = 0 ;
4522   PyObject * obj4 = 0 ;
4523   PyObject * obj5 = 0 ;
4524   char *  kwnames[] = {
4525     (char *) "self",(char *) "base",(char *) "scope",(char *) "expression",(char *) "attrs",(char *) "controls", NULL
4526   };
4527
4528   arg2 = NULL;
4529   arg8 = &temp_ldb_result8;
4530   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:Ldb_search_ex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4531   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4532   if (!SWIG_IsOK(res1)) {
4533     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_search_ex" "', argument " "1"" of type '" "ldb *""'");
4534   }
4535   arg1 = (ldb *)(argp1);
4536   if (obj1) {
4537     if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg3) != 0) {
4538       SWIG_fail;
4539     }
4540   }
4541   if (obj2) {
4542     ecode4 = SWIG_AsVal_int(obj2, &val4);
4543     if (!SWIG_IsOK(ecode4)) {
4544       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Ldb_search_ex" "', argument " "4"" of type '" "enum ldb_scope""'");
4545     }
4546     arg4 = (enum ldb_scope)(val4);
4547   }
4548   if (obj3) {
4549     res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
4550     if (!SWIG_IsOK(res5)) {
4551       SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Ldb_search_ex" "', argument " "5"" of type '" "char const *""'");
4552     }
4553     arg5 = (char *)(buf5);
4554   }
4555   if (obj4) {
4556     if (obj4 == Py_None) {
4557       arg6 = NULL;
4558     } else if (PySequence_Check(obj4)) {
4559       int i;
4560       arg6 = talloc_array(NULL, char *, PySequence_Size(obj4)+1);
4561       for(i = 0; i < PySequence_Size(obj4); i++)
4562       arg6[i] = PyString_AsString(PySequence_GetItem(obj4, i));
4563       arg6[i] = NULL;
4564     } else {
4565       SWIG_exception(SWIG_TypeError, "expected sequence");
4566     }
4567   }
4568   if (obj5) {
4569     res7 = SWIG_ConvertPtr(obj5, &argp7,SWIGTYPE_p_p_ldb_control, 0 |  0 );
4570     if (!SWIG_IsOK(res7)) {
4571       SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Ldb_search_ex" "', argument " "7"" of type '" "struct ldb_control **""'");
4572     }
4573     arg7 = (struct ldb_control **)(argp7);
4574   }
4575   if (arg1 == NULL)
4576   SWIG_exception(SWIG_ValueError,
4577     "ldb context must be non-NULL");
4578   result = ldb_search_ex(arg1,arg2,arg3,arg4,(char const *)arg5,(char const *const *)arg6,arg7,arg8);
4579   if (result != 0) {
4580     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
4581     SWIG_fail;
4582   }
4583   resultobj = Py_None;
4584   resultobj = PyList_New((*arg8)->count);
4585   for (i8 = 0; i8 < (*arg8)->count; i8++) {
4586     PyList_SetItem(resultobj, i8,
4587       SWIG_NewPointerObj((*arg8)->msgs[i8], SWIGTYPE_p_ldb_message, 0)
4588       );
4589   }
4590   talloc_free(arg3);
4591   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
4592   talloc_free(arg6);
4593   return resultobj;
4594 fail:
4595   talloc_free(arg3);
4596   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
4597   talloc_free(arg6);
4598   return NULL;
4599 }
4600
4601
4602 SWIGINTERN PyObject *_wrap_Ldb_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4603   PyObject *resultobj = 0;
4604   ldb *arg1 = (ldb *) 0 ;
4605   ldb_dn *arg2 = (ldb_dn *) 0 ;
4606   ldb_error result;
4607   void *argp1 = 0 ;
4608   int res1 = 0 ;
4609   PyObject * obj0 = 0 ;
4610   PyObject * obj1 = 0 ;
4611   char *  kwnames[] = {
4612     (char *) "self",(char *) "dn", NULL
4613   };
4614
4615   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_delete",kwnames,&obj0,&obj1)) SWIG_fail;
4616   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4617   if (!SWIG_IsOK(res1)) {
4618     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_delete" "', argument " "1"" of type '" "ldb *""'");
4619   }
4620   arg1 = (ldb *)(argp1);
4621   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
4622     SWIG_fail;
4623   }
4624   if (arg1 == NULL)
4625   SWIG_exception(SWIG_ValueError,
4626     "ldb context must be non-NULL");
4627   result = ldb_delete(arg1,arg2);
4628   if (result != 0) {
4629     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
4630     SWIG_fail;
4631   }
4632   resultobj = Py_None;
4633   talloc_free(arg2);
4634   return resultobj;
4635 fail:
4636   talloc_free(arg2);
4637   return NULL;
4638 }
4639
4640
4641 SWIGINTERN PyObject *_wrap_Ldb_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4642   PyObject *resultobj = 0;
4643   ldb *arg1 = (ldb *) 0 ;
4644   ldb_dn *arg2 = (ldb_dn *) 0 ;
4645   ldb_dn *arg3 = (ldb_dn *) 0 ;
4646   ldb_error result;
4647   void *argp1 = 0 ;
4648   int res1 = 0 ;
4649   PyObject * obj0 = 0 ;
4650   PyObject * obj1 = 0 ;
4651   PyObject * obj2 = 0 ;
4652   char *  kwnames[] = {
4653     (char *) "self",(char *) "olddn",(char *) "newdn", NULL
4654   };
4655
4656   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_rename",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4657   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4658   if (!SWIG_IsOK(res1)) {
4659     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_rename" "', argument " "1"" of type '" "ldb *""'");
4660   }
4661   arg1 = (ldb *)(argp1);
4662   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
4663     SWIG_fail;
4664   }
4665   if (ldb_dn_from_pyobject(NULL, obj2, arg1, &arg3) != 0) {
4666     SWIG_fail;
4667   }
4668   if (arg1 == NULL)
4669   SWIG_exception(SWIG_ValueError,
4670     "ldb context must be non-NULL");
4671   result = ldb_rename(arg1,arg2,arg3);
4672   if (result != 0) {
4673     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
4674     SWIG_fail;
4675   }
4676   resultobj = Py_None;
4677   talloc_free(arg2);
4678   talloc_free(arg3);
4679   return resultobj;
4680 fail:
4681   talloc_free(arg2);
4682   talloc_free(arg3);
4683   return NULL;
4684 }
4685
4686
4687 SWIGINTERN PyObject *_wrap_Ldb_parse_control_strings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4688   PyObject *resultobj = 0;
4689   ldb *arg1 = (ldb *) 0 ;
4690   TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
4691   char **arg3 = (char **) 0 ;
4692   struct ldb_control **result = 0 ;
4693   void *argp1 = 0 ;
4694   int res1 = 0 ;
4695   PyObject * obj0 = 0 ;
4696   PyObject * obj1 = 0 ;
4697   char *  kwnames[] = {
4698     (char *) "self",(char *) "control_strings", NULL
4699   };
4700
4701   arg2 = NULL;
4702   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_control_strings",kwnames,&obj0,&obj1)) SWIG_fail;
4703   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4704   if (!SWIG_IsOK(res1)) {
4705     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_control_strings" "', argument " "1"" of type '" "ldb *""'");
4706   }
4707   arg1 = (ldb *)(argp1);
4708   if (obj1 == Py_None) {
4709     arg3 = NULL;
4710   } else if (PySequence_Check(obj1)) {
4711     int i;
4712     arg3 = talloc_array(NULL, char *, PySequence_Size(obj1)+1);
4713     for(i = 0; i < PySequence_Size(obj1); i++)
4714     arg3[i] = PyString_AsString(PySequence_GetItem(obj1, i));
4715     arg3[i] = NULL;
4716   } else {
4717     SWIG_exception(SWIG_TypeError, "expected sequence");
4718   }
4719   if (arg1 == NULL)
4720   SWIG_exception(SWIG_ValueError,
4721     "ldb context must be non-NULL");
4722   result = (struct ldb_control **)ldb_parse_control_strings(arg1,arg2,(char const *const *)arg3);
4723   if (result == NULL) {
4724     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(s)", ldb_errstring(arg1)));
4725     SWIG_fail;
4726   }
4727   resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_p_ldb_control, 0);
4728   talloc_free(arg3);
4729   return resultobj;
4730 fail:
4731   talloc_free(arg3);
4732   return NULL;
4733 }
4734
4735
4736 SWIGINTERN PyObject *_wrap_Ldb_add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4737   PyObject *resultobj = 0;
4738   ldb *arg1 = (ldb *) 0 ;
4739   ldb_msg *arg2 = (ldb_msg *) 0 ;
4740   ldb_error result;
4741   void *argp1 = 0 ;
4742   int res1 = 0 ;
4743   void *argp2 = 0 ;
4744   int res2 = 0 ;
4745
4746   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
4747   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4748   if (!SWIG_IsOK(res1)) {
4749     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_add" "', argument " "1"" of type '" "ldb *""'");
4750   }
4751   arg1 = (ldb *)(argp1);
4752   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_message, 0 |  0 );
4753   if (!SWIG_IsOK(res2)) {
4754     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_add" "', argument " "2"" of type '" "ldb_msg *""'");
4755   }
4756   arg2 = (ldb_msg *)(argp2);
4757   if (arg1 == NULL)
4758   SWIG_exception(SWIG_ValueError,
4759     "ldb context must be non-NULL");
4760   if (arg2 == NULL)
4761   SWIG_exception(SWIG_ValueError,
4762     "Message can not be None");
4763   result = ldb_add(arg1,arg2);
4764   if (result != 0) {
4765     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
4766     SWIG_fail;
4767   }
4768   resultobj = Py_None;
4769   return resultobj;
4770 fail:
4771   return NULL;
4772 }
4773
4774
4775 SWIGINTERN PyObject *_wrap_Ldb_add__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4776   PyObject *resultobj = 0;
4777   ldb *arg1 = (ldb *) 0 ;
4778   PyObject *arg2 = (PyObject *) 0 ;
4779   ldb_error result;
4780   void *argp1 = 0 ;
4781   int res1 = 0 ;
4782
4783   if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
4784   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4785   if (!SWIG_IsOK(res1)) {
4786     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_add" "', argument " "1"" of type '" "ldb *""'");
4787   }
4788   arg1 = (ldb *)(argp1);
4789   arg2 = swig_obj[1];
4790   if (arg1 == NULL)
4791   SWIG_exception(SWIG_ValueError,
4792     "ldb context must be non-NULL");
4793   result = ldb_add__SWIG_1(arg1,arg2);
4794   if (result != 0) {
4795     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
4796     SWIG_fail;
4797   }
4798   resultobj = Py_None;
4799   return resultobj;
4800 fail:
4801   return NULL;
4802 }
4803
4804
4805 SWIGINTERN PyObject *_wrap_Ldb_add(PyObject *self, PyObject *args) {
4806   int argc;
4807   PyObject *argv[3];
4808
4809   if (!(argc = SWIG_Python_UnpackTuple(args,"Ldb_add",0,2,argv))) SWIG_fail;
4810   --argc;
4811   if (argc == 2) {
4812     int _v = 0;
4813     {
4814       void *vptr = 0;
4815       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ldb_message, 0);
4816       _v = SWIG_CheckState(res);
4817     }
4818     if (!_v) goto check_1;
4819     return _wrap_Ldb_add__SWIG_0(self, argc, argv);
4820   }
4821 check_1:
4822
4823   if (argc == 2) {
4824     return _wrap_Ldb_add__SWIG_1(self, argc, argv);
4825   }
4826
4827 fail:
4828   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Ldb_add'.\n  Possible C/C++ prototypes are:\n""    add(ldb *,ldb_msg *)\n""    add(ldb *,PyObject *)\n");
4829   return NULL;
4830 }
4831
4832
4833 SWIGINTERN PyObject *_wrap_Ldb_modify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4834   PyObject *resultobj = 0;
4835   ldb *arg1 = (ldb *) 0 ;
4836   ldb_msg *arg2 = (ldb_msg *) 0 ;
4837   ldb_error result;
4838   void *argp1 = 0 ;
4839   int res1 = 0 ;
4840   void *argp2 = 0 ;
4841   int res2 = 0 ;
4842   PyObject * obj0 = 0 ;
4843   PyObject * obj1 = 0 ;
4844   char *  kwnames[] = {
4845     (char *) "self",(char *) "message", NULL
4846   };
4847
4848   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_modify",kwnames,&obj0,&obj1)) SWIG_fail;
4849   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4850   if (!SWIG_IsOK(res1)) {
4851     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_modify" "', argument " "1"" of type '" "ldb *""'");
4852   }
4853   arg1 = (ldb *)(argp1);
4854   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 |  0 );
4855   if (!SWIG_IsOK(res2)) {
4856     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_modify" "', argument " "2"" of type '" "ldb_msg *""'");
4857   }
4858   arg2 = (ldb_msg *)(argp2);
4859   if (arg1 == NULL)
4860   SWIG_exception(SWIG_ValueError,
4861     "ldb context must be non-NULL");
4862   if (arg2 == NULL)
4863   SWIG_exception(SWIG_ValueError,
4864     "Message can not be None");
4865   result = ldb_modify(arg1,arg2);
4866   if (result != 0) {
4867     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
4868     SWIG_fail;
4869   }
4870   resultobj = Py_None;
4871   return resultobj;
4872 fail:
4873   return NULL;
4874 }
4875
4876
4877 SWIGINTERN PyObject *_wrap_Ldb_get_config_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4878   PyObject *resultobj = 0;
4879   ldb *arg1 = (ldb *) 0 ;
4880   ldb_dn *result = 0 ;
4881   void *argp1 = 0 ;
4882   int res1 = 0 ;
4883   PyObject *swig_obj[1] ;
4884
4885   if (!args) SWIG_fail;
4886   swig_obj[0] = args;
4887   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4888   if (!SWIG_IsOK(res1)) {
4889     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_config_basedn" "', argument " "1"" of type '" "ldb *""'");
4890   }
4891   arg1 = (ldb *)(argp1);
4892   if (arg1 == NULL)
4893   SWIG_exception(SWIG_ValueError,
4894     "ldb context must be non-NULL");
4895   result = (ldb_dn *)ldb_get_config_basedn(arg1);
4896   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4897   return resultobj;
4898 fail:
4899   return NULL;
4900 }
4901
4902
4903 SWIGINTERN PyObject *_wrap_Ldb_get_root_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4904   PyObject *resultobj = 0;
4905   ldb *arg1 = (ldb *) 0 ;
4906   ldb_dn *result = 0 ;
4907   void *argp1 = 0 ;
4908   int res1 = 0 ;
4909   PyObject *swig_obj[1] ;
4910
4911   if (!args) SWIG_fail;
4912   swig_obj[0] = args;
4913   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4914   if (!SWIG_IsOK(res1)) {
4915     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_root_basedn" "', argument " "1"" of type '" "ldb *""'");
4916   }
4917   arg1 = (ldb *)(argp1);
4918   if (arg1 == NULL)
4919   SWIG_exception(SWIG_ValueError,
4920     "ldb context must be non-NULL");
4921   result = (ldb_dn *)ldb_get_root_basedn(arg1);
4922   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4923   return resultobj;
4924 fail:
4925   return NULL;
4926 }
4927
4928
4929 SWIGINTERN PyObject *_wrap_Ldb_get_schema_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4930   PyObject *resultobj = 0;
4931   ldb *arg1 = (ldb *) 0 ;
4932   ldb_dn *result = 0 ;
4933   void *argp1 = 0 ;
4934   int res1 = 0 ;
4935   PyObject *swig_obj[1] ;
4936
4937   if (!args) SWIG_fail;
4938   swig_obj[0] = args;
4939   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4940   if (!SWIG_IsOK(res1)) {
4941     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_schema_basedn" "', argument " "1"" of type '" "ldb *""'");
4942   }
4943   arg1 = (ldb *)(argp1);
4944   if (arg1 == NULL)
4945   SWIG_exception(SWIG_ValueError,
4946     "ldb context must be non-NULL");
4947   result = (ldb_dn *)ldb_get_schema_basedn(arg1);
4948   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4949   return resultobj;
4950 fail:
4951   return NULL;
4952 }
4953
4954
4955 SWIGINTERN PyObject *_wrap_Ldb_get_default_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4956   PyObject *resultobj = 0;
4957   ldb *arg1 = (ldb *) 0 ;
4958   ldb_dn *result = 0 ;
4959   void *argp1 = 0 ;
4960   int res1 = 0 ;
4961   PyObject *swig_obj[1] ;
4962
4963   if (!args) SWIG_fail;
4964   swig_obj[0] = args;
4965   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4966   if (!SWIG_IsOK(res1)) {
4967     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_default_basedn" "', argument " "1"" of type '" "ldb *""'");
4968   }
4969   arg1 = (ldb *)(argp1);
4970   if (arg1 == NULL)
4971   SWIG_exception(SWIG_ValueError,
4972     "ldb context must be non-NULL");
4973   result = (ldb_dn *)ldb_get_default_basedn(arg1);
4974   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4975   return resultobj;
4976 fail:
4977   return NULL;
4978 }
4979
4980
4981 SWIGINTERN PyObject *_wrap_Ldb_schema_format_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4982   PyObject *resultobj = 0;
4983   ldb *arg1 = (ldb *) 0 ;
4984   char *arg2 = (char *) 0 ;
4985   PyObject *arg3 = (PyObject *) 0 ;
4986   PyObject *result = 0 ;
4987   void *argp1 = 0 ;
4988   int res1 = 0 ;
4989   int res2 ;
4990   char *buf2 = 0 ;
4991   int alloc2 = 0 ;
4992   PyObject * obj0 = 0 ;
4993   PyObject * obj1 = 0 ;
4994   PyObject * obj2 = 0 ;
4995   char *  kwnames[] = {
4996     (char *) "self",(char *) "element_name",(char *) "val", NULL
4997   };
4998
4999   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_schema_format_value",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5000   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5001   if (!SWIG_IsOK(res1)) {
5002     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_format_value" "', argument " "1"" of type '" "ldb *""'");
5003   }
5004   arg1 = (ldb *)(argp1);
5005   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5006   if (!SWIG_IsOK(res2)) {
5007     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_format_value" "', argument " "2"" of type '" "char const *""'");
5008   }
5009   arg2 = (char *)(buf2);
5010   arg3 = obj2;
5011   if (arg1 == NULL)
5012   SWIG_exception(SWIG_ValueError,
5013     "ldb context must be non-NULL");
5014   result = (PyObject *)ldb_schema_format_value(arg1,(char const *)arg2,arg3);
5015   resultobj = result;
5016   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5017   return resultobj;
5018 fail:
5019   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5020   return NULL;
5021 }
5022
5023
5024 SWIGINTERN PyObject *_wrap_Ldb_errstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5025   PyObject *resultobj = 0;
5026   ldb *arg1 = (ldb *) 0 ;
5027   char *result = 0 ;
5028   void *argp1 = 0 ;
5029   int res1 = 0 ;
5030   PyObject *swig_obj[1] ;
5031
5032   if (!args) SWIG_fail;
5033   swig_obj[0] = args;
5034   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5035   if (!SWIG_IsOK(res1)) {
5036     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_errstring" "', argument " "1"" of type '" "ldb *""'");
5037   }
5038   arg1 = (ldb *)(argp1);
5039   if (arg1 == NULL)
5040   SWIG_exception(SWIG_ValueError,
5041     "ldb context must be non-NULL");
5042   result = (char *)ldb_errstring(arg1);
5043   resultobj = SWIG_FromCharPtr((const char *)result);
5044   return resultobj;
5045 fail:
5046   return NULL;
5047 }
5048
5049
5050 SWIGINTERN PyObject *_wrap_Ldb_set_create_perms(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5051   PyObject *resultobj = 0;
5052   ldb *arg1 = (ldb *) 0 ;
5053   unsigned int arg2 ;
5054   void *argp1 = 0 ;
5055   int res1 = 0 ;
5056   unsigned int val2 ;
5057   int ecode2 = 0 ;
5058   PyObject * obj0 = 0 ;
5059   PyObject * obj1 = 0 ;
5060   char *  kwnames[] = {
5061     (char *) "self",(char *) "perms", NULL
5062   };
5063
5064   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_create_perms",kwnames,&obj0,&obj1)) SWIG_fail;
5065   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5066   if (!SWIG_IsOK(res1)) {
5067     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_create_perms" "', argument " "1"" of type '" "ldb *""'");
5068   }
5069   arg1 = (ldb *)(argp1);
5070   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5071   if (!SWIG_IsOK(ecode2)) {
5072     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ldb_set_create_perms" "', argument " "2"" of type '" "unsigned int""'");
5073   }
5074   arg2 = (unsigned int)(val2);
5075   if (arg1 == NULL)
5076   SWIG_exception(SWIG_ValueError,
5077     "ldb context must be non-NULL");
5078   ldb_set_create_perms(arg1,arg2);
5079   resultobj = SWIG_Py_Void();
5080   return resultobj;
5081 fail:
5082   return NULL;
5083 }
5084
5085
5086 SWIGINTERN PyObject *_wrap_Ldb_set_modules_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5087   PyObject *resultobj = 0;
5088   ldb *arg1 = (ldb *) 0 ;
5089   char *arg2 = (char *) 0 ;
5090   void *argp1 = 0 ;
5091   int res1 = 0 ;
5092   int res2 ;
5093   char *buf2 = 0 ;
5094   int alloc2 = 0 ;
5095   PyObject * obj0 = 0 ;
5096   PyObject * obj1 = 0 ;
5097   char *  kwnames[] = {
5098     (char *) "self",(char *) "path", NULL
5099   };
5100
5101   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_modules_dir",kwnames,&obj0,&obj1)) SWIG_fail;
5102   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5103   if (!SWIG_IsOK(res1)) {
5104     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_modules_dir" "', argument " "1"" of type '" "ldb *""'");
5105   }
5106   arg1 = (ldb *)(argp1);
5107   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5108   if (!SWIG_IsOK(res2)) {
5109     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_modules_dir" "', argument " "2"" of type '" "char const *""'");
5110   }
5111   arg2 = (char *)(buf2);
5112   if (arg1 == NULL)
5113   SWIG_exception(SWIG_ValueError,
5114     "ldb context must be non-NULL");
5115   ldb_set_modules_dir(arg1,(char const *)arg2);
5116   resultobj = SWIG_Py_Void();
5117   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5118   return resultobj;
5119 fail:
5120   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5121   return NULL;
5122 }
5123
5124
5125 SWIGINTERN PyObject *_wrap_Ldb_set_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5126   PyObject *resultobj = 0;
5127   ldb *arg1 = (ldb *) 0 ;
5128   void (*arg2)(void *,enum ldb_debug_level,char const *,va_list) = (void (*)(void *,enum ldb_debug_level,char const *,va_list)) 0 ;
5129   void *arg3 = (void *) 0 ;
5130   ldb_error result;
5131   void *argp1 = 0 ;
5132   int res1 = 0 ;
5133   PyObject * obj0 = 0 ;
5134   PyObject * obj1 = 0 ;
5135   char *  kwnames[] = {
5136     (char *) "self",(char *) "debug", NULL
5137   };
5138
5139   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_debug",kwnames,&obj0,&obj1)) SWIG_fail;
5140   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5141   if (!SWIG_IsOK(res1)) {
5142     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_debug" "', argument " "1"" of type '" "ldb *""'");
5143   }
5144   arg1 = (ldb *)(argp1);
5145   arg2 = py_ldb_debug;
5146   /* FIXME: Should be decreased somewhere as well. Perhaps register a
5147          destructor and tie it to the ldb context ? */
5148   Py_INCREF(obj1);
5149   arg3 = obj1;
5150   if (arg1 == NULL)
5151   SWIG_exception(SWIG_ValueError,
5152     "ldb context must be non-NULL");
5153   result = ldb_set_debug(arg1,arg2,arg3);
5154   if (result != 0) {
5155     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
5156     SWIG_fail;
5157   }
5158   resultobj = Py_None;
5159   return resultobj;
5160 fail:
5161   return NULL;
5162 }
5163
5164
5165 SWIGINTERN PyObject *_wrap_Ldb_set_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5166   PyObject *resultobj = 0;
5167   ldb *arg1 = (ldb *) 0 ;
5168   char *arg2 = (char *) 0 ;
5169   void *arg3 = (void *) 0 ;
5170   ldb_error result;
5171   void *argp1 = 0 ;
5172   int res1 = 0 ;
5173   int res2 ;
5174   char *buf2 = 0 ;
5175   int alloc2 = 0 ;
5176   int res3 ;
5177   PyObject * obj0 = 0 ;
5178   PyObject * obj1 = 0 ;
5179   PyObject * obj2 = 0 ;
5180   char *  kwnames[] = {
5181     (char *) "self",(char *) "name",(char *) "value", NULL
5182   };
5183
5184   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_set_opaque",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5185   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5186   if (!SWIG_IsOK(res1)) {
5187     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_opaque" "', argument " "1"" of type '" "ldb *""'");
5188   }
5189   arg1 = (ldb *)(argp1);
5190   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5191   if (!SWIG_IsOK(res2)) {
5192     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_opaque" "', argument " "2"" of type '" "char const *""'");
5193   }
5194   arg2 = (char *)(buf2);
5195   res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
5196   if (!SWIG_IsOK(res3)) {
5197     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ldb_set_opaque" "', argument " "3"" of type '" "void *""'");
5198   }
5199   if (arg1 == NULL)
5200   SWIG_exception(SWIG_ValueError,
5201     "ldb context must be non-NULL");
5202   result = ldb_set_opaque(arg1,(char const *)arg2,arg3);
5203   if (result != 0) {
5204     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
5205     SWIG_fail;
5206   }
5207   resultobj = Py_None;
5208   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5209   return resultobj;
5210 fail:
5211   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5212   return NULL;
5213 }
5214
5215
5216 SWIGINTERN PyObject *_wrap_Ldb_get_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5217   PyObject *resultobj = 0;
5218   ldb *arg1 = (ldb *) 0 ;
5219   char *arg2 = (char *) 0 ;
5220   void *result = 0 ;
5221   void *argp1 = 0 ;
5222   int res1 = 0 ;
5223   int res2 ;
5224   char *buf2 = 0 ;
5225   int alloc2 = 0 ;
5226   PyObject * obj0 = 0 ;
5227   PyObject * obj1 = 0 ;
5228   char *  kwnames[] = {
5229     (char *) "self",(char *) "name", NULL
5230   };
5231
5232   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_get_opaque",kwnames,&obj0,&obj1)) SWIG_fail;
5233   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5234   if (!SWIG_IsOK(res1)) {
5235     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_opaque" "', argument " "1"" of type '" "ldb *""'");
5236   }
5237   arg1 = (ldb *)(argp1);
5238   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5239   if (!SWIG_IsOK(res2)) {
5240     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_get_opaque" "', argument " "2"" of type '" "char const *""'");
5241   }
5242   arg2 = (char *)(buf2);
5243   if (arg1 == NULL)
5244   SWIG_exception(SWIG_ValueError,
5245     "ldb context must be non-NULL");
5246   result = (void *)ldb_get_opaque(arg1,(char const *)arg2);
5247   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
5248   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5249   return resultobj;
5250 fail:
5251   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5252   return NULL;
5253 }
5254
5255
5256 SWIGINTERN PyObject *_wrap_Ldb_transaction_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5257   PyObject *resultobj = 0;
5258   ldb *arg1 = (ldb *) 0 ;
5259   ldb_error result;
5260   void *argp1 = 0 ;
5261   int res1 = 0 ;
5262   PyObject *swig_obj[1] ;
5263
5264   if (!args) SWIG_fail;
5265   swig_obj[0] = args;
5266   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5267   if (!SWIG_IsOK(res1)) {
5268     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_start" "', argument " "1"" of type '" "ldb *""'");
5269   }
5270   arg1 = (ldb *)(argp1);
5271   if (arg1 == NULL)
5272   SWIG_exception(SWIG_ValueError,
5273     "ldb context must be non-NULL");
5274   result = ldb_transaction_start(arg1);
5275   if (result != 0) {
5276     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
5277     SWIG_fail;
5278   }
5279   resultobj = Py_None;
5280   return resultobj;
5281 fail:
5282   return NULL;
5283 }
5284
5285
5286 SWIGINTERN PyObject *_wrap_Ldb_transaction_commit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5287   PyObject *resultobj = 0;
5288   ldb *arg1 = (ldb *) 0 ;
5289   ldb_error result;
5290   void *argp1 = 0 ;
5291   int res1 = 0 ;
5292   PyObject *swig_obj[1] ;
5293
5294   if (!args) SWIG_fail;
5295   swig_obj[0] = args;
5296   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5297   if (!SWIG_IsOK(res1)) {
5298     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_commit" "', argument " "1"" of type '" "ldb *""'");
5299   }
5300   arg1 = (ldb *)(argp1);
5301   if (arg1 == NULL)
5302   SWIG_exception(SWIG_ValueError,
5303     "ldb context must be non-NULL");
5304   result = ldb_transaction_commit(arg1);
5305   if (result != 0) {
5306     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
5307     SWIG_fail;
5308   }
5309   resultobj = Py_None;
5310   return resultobj;
5311 fail:
5312   return NULL;
5313 }
5314
5315
5316 SWIGINTERN PyObject *_wrap_Ldb_transaction_cancel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5317   PyObject *resultobj = 0;
5318   ldb *arg1 = (ldb *) 0 ;
5319   ldb_error result;
5320   void *argp1 = 0 ;
5321   int res1 = 0 ;
5322   PyObject *swig_obj[1] ;
5323
5324   if (!args) SWIG_fail;
5325   swig_obj[0] = args;
5326   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5327   if (!SWIG_IsOK(res1)) {
5328     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_cancel" "', argument " "1"" of type '" "ldb *""'");
5329   }
5330   arg1 = (ldb *)(argp1);
5331   if (arg1 == NULL)
5332   SWIG_exception(SWIG_ValueError,
5333     "ldb context must be non-NULL");
5334   result = ldb_transaction_cancel(arg1);
5335   if (result != 0) {
5336     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
5337     SWIG_fail;
5338   }
5339   resultobj = Py_None;
5340   return resultobj;
5341 fail:
5342   return NULL;
5343 }
5344
5345
5346 SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5347   PyObject *resultobj = 0;
5348   ldb *arg1 = (ldb *) 0 ;
5349   char *arg2 = (char *) 0 ;
5350   void *argp1 = 0 ;
5351   int res1 = 0 ;
5352   int res2 ;
5353   char *buf2 = 0 ;
5354   int alloc2 = 0 ;
5355   PyObject * obj0 = 0 ;
5356   PyObject * obj1 = 0 ;
5357   char *  kwnames[] = {
5358     (char *) "self",(char *) "name", NULL
5359   };
5360
5361   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_schema_attribute_remove",kwnames,&obj0,&obj1)) SWIG_fail;
5362   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5363   if (!SWIG_IsOK(res1)) {
5364     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_remove" "', argument " "1"" of type '" "ldb *""'");
5365   }
5366   arg1 = (ldb *)(argp1);
5367   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5368   if (!SWIG_IsOK(res2)) {
5369     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_remove" "', argument " "2"" of type '" "char const *""'");
5370   }
5371   arg2 = (char *)(buf2);
5372   if (arg1 == NULL)
5373   SWIG_exception(SWIG_ValueError,
5374     "ldb context must be non-NULL");
5375   ldb_schema_attribute_remove(arg1,(char const *)arg2);
5376   resultobj = SWIG_Py_Void();
5377   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5378   return resultobj;
5379 fail:
5380   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5381   return NULL;
5382 }
5383
5384
5385 SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5386   PyObject *resultobj = 0;
5387   ldb *arg1 = (ldb *) 0 ;
5388   char *arg2 = (char *) 0 ;
5389   unsigned int arg3 ;
5390   char *arg4 = (char *) 0 ;
5391   ldb_error result;
5392   void *argp1 = 0 ;
5393   int res1 = 0 ;
5394   int res2 ;
5395   char *buf2 = 0 ;
5396   int alloc2 = 0 ;
5397   unsigned int val3 ;
5398   int ecode3 = 0 ;
5399   int res4 ;
5400   char *buf4 = 0 ;
5401   int alloc4 = 0 ;
5402   PyObject * obj0 = 0 ;
5403   PyObject * obj1 = 0 ;
5404   PyObject * obj2 = 0 ;
5405   PyObject * obj3 = 0 ;
5406   char *  kwnames[] = {
5407     (char *) "self",(char *) "attribute",(char *) "flags",(char *) "syntax", NULL
5408   };
5409
5410   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Ldb_schema_attribute_add",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5411   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5412   if (!SWIG_IsOK(res1)) {
5413     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_add" "', argument " "1"" of type '" "ldb *""'");
5414   }
5415   arg1 = (ldb *)(argp1);
5416   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5417   if (!SWIG_IsOK(res2)) {
5418     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_add" "', argument " "2"" of type '" "char const *""'");
5419   }
5420   arg2 = (char *)(buf2);
5421   ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
5422   if (!SWIG_IsOK(ecode3)) {
5423     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_schema_attribute_add" "', argument " "3"" of type '" "unsigned int""'");
5424   }
5425   arg3 = (unsigned int)(val3);
5426   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5427   if (!SWIG_IsOK(res4)) {
5428     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_schema_attribute_add" "', argument " "4"" of type '" "char const *""'");
5429   }
5430   arg4 = (char *)(buf4);
5431   if (arg1 == NULL)
5432   SWIG_exception(SWIG_ValueError,
5433     "ldb context must be non-NULL");
5434   result = ldb_schema_attribute_add(arg1,(char const *)arg2,arg3,(char const *)arg4);
5435   if (result != 0) {
5436     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
5437     SWIG_fail;
5438   }
5439   resultobj = Py_None;
5440   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5441   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5442   return resultobj;
5443 fail:
5444   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5445   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5446   return NULL;
5447 }
5448
5449
5450 SWIGINTERN PyObject *_wrap_Ldb_setup_wellknown_attributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5451   PyObject *resultobj = 0;
5452   ldb *arg1 = (ldb *) 0 ;
5453   ldb_error result;
5454   void *argp1 = 0 ;
5455   int res1 = 0 ;
5456   PyObject *swig_obj[1] ;
5457
5458   if (!args) SWIG_fail;
5459   swig_obj[0] = args;
5460   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5461   if (!SWIG_IsOK(res1)) {
5462     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_setup_wellknown_attributes" "', argument " "1"" of type '" "ldb *""'");
5463   }
5464   arg1 = (ldb *)(argp1);
5465   if (arg1 == NULL)
5466   SWIG_exception(SWIG_ValueError,
5467     "ldb context must be non-NULL");
5468   result = ldb_setup_wellknown_attributes(arg1);
5469   if (result != 0) {
5470     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
5471     SWIG_fail;
5472   }
5473   resultobj = Py_None;
5474   return resultobj;
5475 fail:
5476   return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_Ldb___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5481   PyObject *resultobj = 0;
5482   ldb *arg1 = (ldb *) 0 ;
5483   ldb_dn *arg2 = (ldb_dn *) 0 ;
5484   struct ldb_result **arg3 = (struct ldb_result **) 0 ;
5485   ldb_error result;
5486   void *argp1 = 0 ;
5487   int res1 = 0 ;
5488   struct ldb_result *tmp3 ;
5489   PyObject * obj0 = 0 ;
5490   PyObject * obj1 = 0 ;
5491   char *  kwnames[] = {
5492     (char *) "self",(char *) "dn", NULL
5493   };
5494
5495   arg3 = &tmp3;
5496   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb___contains__",kwnames,&obj0,&obj1)) SWIG_fail;
5497   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5498   if (!SWIG_IsOK(res1)) {
5499     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___contains__" "', argument " "1"" of type '" "ldb *""'");
5500   }
5501   arg1 = (ldb *)(argp1);
5502   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
5503     SWIG_fail;
5504   }
5505   if (arg1 == NULL)
5506   SWIG_exception(SWIG_ValueError,
5507     "ldb context must be non-NULL");
5508   result = ldb___contains__(arg1,arg2,arg3);
5509   if (result != 0) {
5510     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
5511     SWIG_fail;
5512   }
5513   resultobj = Py_None;
5514   resultobj = ((*arg3)->count > 0)?Py_True:Py_False;
5515   talloc_free(arg2);
5516   talloc_free(*arg3);
5517   return resultobj;
5518 fail:
5519   talloc_free(arg2);
5520   talloc_free(*arg3);
5521   return NULL;
5522 }
5523
5524
5525 SWIGINTERN PyObject *_wrap_Ldb_parse_ldif(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5526   PyObject *resultobj = 0;
5527   ldb *arg1 = (ldb *) 0 ;
5528   char *arg2 = (char *) 0 ;
5529   PyObject *result = 0 ;
5530   void *argp1 = 0 ;
5531   int res1 = 0 ;
5532   int res2 ;
5533   char *buf2 = 0 ;
5534   int alloc2 = 0 ;
5535   PyObject * obj0 = 0 ;
5536   PyObject * obj1 = 0 ;
5537   char *  kwnames[] = {
5538     (char *) "self",(char *) "s", NULL
5539   };
5540
5541   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_ldif",kwnames,&obj0,&obj1)) SWIG_fail;
5542   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5543   if (!SWIG_IsOK(res1)) {
5544     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_ldif" "', argument " "1"" of type '" "ldb *""'");
5545   }
5546   arg1 = (ldb *)(argp1);
5547   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5548   if (!SWIG_IsOK(res2)) {
5549     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_parse_ldif" "', argument " "2"" of type '" "char const *""'");
5550   }
5551   arg2 = (char *)(buf2);
5552   if (arg1 == NULL)
5553   SWIG_exception(SWIG_ValueError,
5554     "ldb context must be non-NULL");
5555   result = (PyObject *)ldb_parse_ldif(arg1,(char const *)arg2);
5556   resultobj = result;
5557   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5558   return resultobj;
5559 fail:
5560   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5561   return NULL;
5562 }
5563
5564
5565 SWIGINTERN PyObject *Ldb_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5566   PyObject *obj;
5567   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5568   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_context, SWIG_NewClientData(obj));
5569   return SWIG_Py_Void();
5570 }
5571
5572 SWIGINTERN PyObject *Ldb_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5573   return SWIG_Python_InitShadowInstance(args);
5574 }
5575
5576 SWIGINTERN PyObject *_wrap_valid_attr_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5577   PyObject *resultobj = 0;
5578   char *arg1 = (char *) 0 ;
5579   int result;
5580   int res1 ;
5581   char *buf1 = 0 ;
5582   int alloc1 = 0 ;
5583   PyObject * obj0 = 0 ;
5584   char *  kwnames[] = {
5585     (char *) "s", NULL
5586   };
5587
5588   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:valid_attr_name",kwnames,&obj0)) SWIG_fail;
5589   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5590   if (!SWIG_IsOK(res1)) {
5591     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "valid_attr_name" "', argument " "1"" of type '" "char const *""'");
5592   }
5593   arg1 = (char *)(buf1);
5594   result = (int)ldb_valid_attr_name((char const *)arg1);
5595   resultobj = SWIG_From_int((int)(result));
5596   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5597   return resultobj;
5598 fail:
5599   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5600   return NULL;
5601 }
5602
5603
5604 SWIGINTERN PyObject *_wrap_timestring(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5605   PyObject *resultobj = 0;
5606   time_t arg1 ;
5607   char *result = 0 ;
5608   unsigned long val1 ;
5609   int ecode1 = 0 ;
5610   PyObject * obj0 = 0 ;
5611   char *  kwnames[] = {
5612     (char *) "t", NULL
5613   };
5614
5615   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:timestring",kwnames,&obj0)) SWIG_fail;
5616   ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5617   if (!SWIG_IsOK(ecode1)) {
5618     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "timestring" "', argument " "1"" of type '" "time_t""'");
5619   }
5620   arg1 = (time_t)(val1);
5621   result = (char *)timestring(arg1);
5622   resultobj = SWIG_FromCharPtr((const char *)result);
5623   return resultobj;
5624 fail:
5625   return NULL;
5626 }
5627
5628
5629 SWIGINTERN PyObject *_wrap_string_to_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5630   PyObject *resultobj = 0;
5631   char *arg1 = (char *) 0 ;
5632   time_t result;
5633   int res1 ;
5634   char *buf1 = 0 ;
5635   int alloc1 = 0 ;
5636   PyObject * obj0 = 0 ;
5637   char *  kwnames[] = {
5638     (char *) "s", NULL
5639   };
5640
5641   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:string_to_time",kwnames,&obj0)) SWIG_fail;
5642   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5643   if (!SWIG_IsOK(res1)) {
5644     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_to_time" "', argument " "1"" of type '" "char const *""'");
5645   }
5646   arg1 = (char *)(buf1);
5647   result = (time_t)ldb_string_to_time((char const *)arg1);
5648   resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5649   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5650   return resultobj;
5651 fail:
5652   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5653   return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_register_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5658   PyObject *resultobj = 0;
5659   struct ldb_module_ops *arg1 = (struct ldb_module_ops *) 0 ;
5660   ldb_error result;
5661   PyObject * obj0 = 0 ;
5662   char *  kwnames[] = {
5663     (char *)"arg1", NULL
5664   };
5665
5666   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:register_module",kwnames,&obj0)) SWIG_fail;
5667   arg1 = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
5668
5669   arg1->name = (char *)PyObject_GetAttrString(obj0, (char *)"name");
5670   result = ldb_register_module((struct ldb_module_ops const *)arg1);
5671   if (result != 0) {
5672     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
5673     SWIG_fail;
5674   }
5675   resultobj = Py_None;
5676   return resultobj;
5677 fail:
5678   return NULL;
5679 }
5680
5681
5682 static PyMethodDef SwigMethods[] = {
5683          { (char *)"ldb_val_to_py_object", (PyCFunction) _wrap_ldb_val_to_py_object, METH_VARARGS | METH_KEYWORDS, NULL},
5684          { (char *)"new_Dn", (PyCFunction) _wrap_new_Dn, METH_VARARGS | METH_KEYWORDS, NULL},
5685          { (char *)"delete_Dn", (PyCFunction)_wrap_delete_Dn, METH_O, NULL},
5686          { (char *)"Dn_validate", (PyCFunction)_wrap_Dn_validate, METH_O, NULL},
5687          { (char *)"Dn_get_casefold", (PyCFunction)_wrap_Dn_get_casefold, METH_O, NULL},
5688          { (char *)"Dn___str__", (PyCFunction)_wrap_Dn___str__, METH_O, NULL},
5689          { (char *)"Dn_parent", (PyCFunction)_wrap_Dn_parent, METH_O, NULL},
5690          { (char *)"Dn___cmp__", (PyCFunction) _wrap_Dn___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
5691          { (char *)"Dn_is_valid", (PyCFunction)_wrap_Dn_is_valid, METH_O, NULL},
5692          { (char *)"Dn_is_special", (PyCFunction)_wrap_Dn_is_special, METH_O, NULL},
5693          { (char *)"Dn_is_null", (PyCFunction)_wrap_Dn_is_null, METH_O, NULL},
5694          { (char *)"Dn_check_special", (PyCFunction) _wrap_Dn_check_special, METH_VARARGS | METH_KEYWORDS, NULL},
5695          { (char *)"Dn___len__", (PyCFunction)_wrap_Dn___len__, METH_O, NULL},
5696          { (char *)"Dn_add_child", (PyCFunction) _wrap_Dn_add_child, METH_VARARGS | METH_KEYWORDS, NULL},
5697          { (char *)"Dn_add_base", (PyCFunction) _wrap_Dn_add_base, METH_VARARGS | METH_KEYWORDS, NULL},
5698          { (char *)"Dn_canonical_str", (PyCFunction)_wrap_Dn_canonical_str, METH_O, NULL},
5699          { (char *)"Dn_canonical_ex_str", (PyCFunction)_wrap_Dn_canonical_ex_str, METH_O, NULL},
5700          { (char *)"Dn___add__", (PyCFunction) _wrap_Dn___add__, METH_VARARGS | METH_KEYWORDS, NULL},
5701          { (char *)"Dn_swigregister", Dn_swigregister, METH_VARARGS, NULL},
5702          { (char *)"Dn_swiginit", Dn_swiginit, METH_VARARGS, NULL},
5703          { (char *)"ldb_msg_element___iter__", (PyCFunction)_wrap_ldb_msg_element___iter__, METH_O, NULL},
5704          { (char *)"ldb_msg_element___set__", (PyCFunction)_wrap_ldb_msg_element___set__, METH_O, NULL},
5705          { (char *)"new_MessageElement", (PyCFunction) _wrap_new_MessageElement, METH_VARARGS | METH_KEYWORDS, NULL},
5706          { (char *)"ldb_msg_element___len__", (PyCFunction)_wrap_ldb_msg_element___len__, METH_O, NULL},
5707          { (char *)"ldb_msg_element_get", (PyCFunction) _wrap_ldb_msg_element_get, METH_VARARGS | METH_KEYWORDS, NULL},
5708          { (char *)"delete_ldb_msg_element", (PyCFunction)_wrap_delete_ldb_msg_element, METH_O, NULL},
5709          { (char *)"ldb_msg_element___cmp__", (PyCFunction) _wrap_ldb_msg_element___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
5710          { (char *)"ldb_msg_element_swigregister", ldb_msg_element_swigregister, METH_VARARGS, NULL},
5711          { (char *)"ldb_msg_list_elements", (PyCFunction) _wrap_ldb_msg_list_elements, METH_VARARGS | METH_KEYWORDS, NULL},
5712          { (char *)"Message_dn_set", _wrap_Message_dn_set, METH_VARARGS, NULL},
5713          { (char *)"Message_dn_get", (PyCFunction)_wrap_Message_dn_get, METH_O, NULL},
5714          { (char *)"new_Message", (PyCFunction) _wrap_new_Message, METH_VARARGS | METH_KEYWORDS, NULL},
5715          { (char *)"delete_Message", (PyCFunction)_wrap_delete_Message, METH_O, NULL},
5716          { (char *)"Message___getitem__", (PyCFunction) _wrap_Message___getitem__, METH_VARARGS | METH_KEYWORDS, NULL},
5717          { (char *)"Message___setitem__", _wrap_Message___setitem__, METH_VARARGS, NULL},
5718          { (char *)"Message___len__", (PyCFunction)_wrap_Message___len__, METH_O, NULL},
5719          { (char *)"Message_keys", (PyCFunction)_wrap_Message_keys, METH_O, NULL},
5720          { (char *)"Message___iter__", (PyCFunction)_wrap_Message___iter__, METH_O, NULL},
5721          { (char *)"Message___delitem__", (PyCFunction) _wrap_Message___delitem__, METH_VARARGS | METH_KEYWORDS, NULL},
5722          { (char *)"Message_swigregister", Message_swigregister, METH_VARARGS, NULL},
5723          { (char *)"Message_swiginit", Message_swiginit, METH_VARARGS, NULL},
5724          { (char *)"ldb_ldif_to_pyobject", (PyCFunction) _wrap_ldb_ldif_to_pyobject, METH_VARARGS | METH_KEYWORDS, NULL},
5725          { (char *)"new_Ldb", (PyCFunction)_wrap_new_Ldb, METH_NOARGS, NULL},
5726          { (char *)"Ldb_connect", (PyCFunction) _wrap_Ldb_connect, METH_VARARGS | METH_KEYWORDS, NULL},
5727          { (char *)"delete_Ldb", (PyCFunction)_wrap_delete_Ldb, METH_O, NULL},
5728          { (char *)"Ldb_search_ex", (PyCFunction) _wrap_Ldb_search_ex, METH_VARARGS | METH_KEYWORDS, NULL},
5729          { (char *)"Ldb_delete", (PyCFunction) _wrap_Ldb_delete, METH_VARARGS | METH_KEYWORDS, NULL},
5730          { (char *)"Ldb_rename", (PyCFunction) _wrap_Ldb_rename, METH_VARARGS | METH_KEYWORDS, NULL},
5731          { (char *)"Ldb_parse_control_strings", (PyCFunction) _wrap_Ldb_parse_control_strings, METH_VARARGS | METH_KEYWORDS, NULL},
5732          { (char *)"Ldb_add", _wrap_Ldb_add, METH_VARARGS, NULL},
5733          { (char *)"Ldb_modify", (PyCFunction) _wrap_Ldb_modify, METH_VARARGS | METH_KEYWORDS, NULL},
5734          { (char *)"Ldb_get_config_basedn", (PyCFunction)_wrap_Ldb_get_config_basedn, METH_O, NULL},
5735          { (char *)"Ldb_get_root_basedn", (PyCFunction)_wrap_Ldb_get_root_basedn, METH_O, NULL},
5736          { (char *)"Ldb_get_schema_basedn", (PyCFunction)_wrap_Ldb_get_schema_basedn, METH_O, NULL},
5737          { (char *)"Ldb_get_default_basedn", (PyCFunction)_wrap_Ldb_get_default_basedn, METH_O, NULL},
5738          { (char *)"Ldb_schema_format_value", (PyCFunction) _wrap_Ldb_schema_format_value, METH_VARARGS | METH_KEYWORDS, NULL},
5739          { (char *)"Ldb_errstring", (PyCFunction)_wrap_Ldb_errstring, METH_O, NULL},
5740          { (char *)"Ldb_set_create_perms", (PyCFunction) _wrap_Ldb_set_create_perms, METH_VARARGS | METH_KEYWORDS, NULL},
5741          { (char *)"Ldb_set_modules_dir", (PyCFunction) _wrap_Ldb_set_modules_dir, METH_VARARGS | METH_KEYWORDS, NULL},
5742          { (char *)"Ldb_set_debug", (PyCFunction) _wrap_Ldb_set_debug, METH_VARARGS | METH_KEYWORDS, NULL},
5743          { (char *)"Ldb_set_opaque", (PyCFunction) _wrap_Ldb_set_opaque, METH_VARARGS | METH_KEYWORDS, NULL},
5744          { (char *)"Ldb_get_opaque", (PyCFunction) _wrap_Ldb_get_opaque, METH_VARARGS | METH_KEYWORDS, NULL},
5745          { (char *)"Ldb_transaction_start", (PyCFunction)_wrap_Ldb_transaction_start, METH_O, NULL},
5746          { (char *)"Ldb_transaction_commit", (PyCFunction)_wrap_Ldb_transaction_commit, METH_O, NULL},
5747          { (char *)"Ldb_transaction_cancel", (PyCFunction)_wrap_Ldb_transaction_cancel, METH_O, NULL},
5748          { (char *)"Ldb_schema_attribute_remove", (PyCFunction) _wrap_Ldb_schema_attribute_remove, METH_VARARGS | METH_KEYWORDS, NULL},
5749          { (char *)"Ldb_schema_attribute_add", (PyCFunction) _wrap_Ldb_schema_attribute_add, METH_VARARGS | METH_KEYWORDS, NULL},
5750          { (char *)"Ldb_setup_wellknown_attributes", (PyCFunction)_wrap_Ldb_setup_wellknown_attributes, METH_O, NULL},
5751          { (char *)"Ldb___contains__", (PyCFunction) _wrap_Ldb___contains__, METH_VARARGS | METH_KEYWORDS, NULL},
5752          { (char *)"Ldb_parse_ldif", (PyCFunction) _wrap_Ldb_parse_ldif, METH_VARARGS | METH_KEYWORDS, NULL},
5753          { (char *)"Ldb_swigregister", Ldb_swigregister, METH_VARARGS, NULL},
5754          { (char *)"Ldb_swiginit", Ldb_swiginit, METH_VARARGS, NULL},
5755          { (char *)"valid_attr_name", (PyCFunction) _wrap_valid_attr_name, METH_VARARGS | METH_KEYWORDS, NULL},
5756          { (char *)"timestring", (PyCFunction) _wrap_timestring, METH_VARARGS | METH_KEYWORDS, NULL},
5757          { (char *)"string_to_time", (PyCFunction) _wrap_string_to_time, METH_VARARGS | METH_KEYWORDS, NULL},
5758          { (char *)"register_module", (PyCFunction) _wrap_register_module, METH_VARARGS | METH_KEYWORDS, NULL},
5759          { NULL, NULL, 0, NULL }
5760 };
5761
5762
5763 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5764
5765 static swig_type_info _swigt__p_TALLOC_CTX = {"_p_TALLOC_CTX", "TALLOC_CTX *", 0, 0, (void*)0, 0};
5766 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
5767 static swig_type_info _swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void = {"_p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void", "void (*)(void *,enum ldb_debug_level,char const *,va_list)", 0, 0, (void*)0, 0};
5768 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};
5769 static swig_type_info _swigt__p_ldb_context = {"_p_ldb_context", "struct ldb_context *|ldb *", 0, 0, (void*)0, 0};
5770 static swig_type_info _swigt__p_ldb_dn = {"_p_ldb_dn", "struct ldb_dn *|ldb_dn *", 0, 0, (void*)0, 0};
5771 static swig_type_info _swigt__p_ldb_ldif = {"_p_ldb_ldif", "struct ldb_ldif *|ldb_ldif *", 0, 0, (void*)0, 0};
5772 static swig_type_info _swigt__p_ldb_message = {"_p_ldb_message", "ldb_msg *|struct ldb_message *", 0, 0, (void*)0, 0};
5773 static swig_type_info _swigt__p_ldb_message_element = {"_p_ldb_message_element", "struct ldb_message_element *|ldb_msg_element *", 0, 0, (void*)0, 0};
5774 static swig_type_info _swigt__p_ldb_module_ops = {"_p_ldb_module_ops", "struct ldb_module_ops *", 0, 0, (void*)0, 0};
5775 static swig_type_info _swigt__p_ldb_result = {"_p_ldb_result", "struct ldb_result *", 0, 0, (void*)0, 0};
5776 static swig_type_info _swigt__p_ldb_val = {"_p_ldb_val", "struct ldb_val *", 0, 0, (void*)0, 0};
5777 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};
5778 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
5779 static swig_type_info _swigt__p_p_ldb_control = {"_p_p_ldb_control", "struct ldb_control **", 0, 0, (void*)0, 0};
5780 static swig_type_info _swigt__p_p_ldb_result = {"_p_p_ldb_result", "struct ldb_result **", 0, 0, (void*)0, 0};
5781 static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
5782 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};
5783 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};
5784 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};
5785 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|time_t *", 0, 0, (void*)0, 0};
5786 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};
5787 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
5788 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
5789
5790 static swig_type_info *swig_type_initial[] = {
5791   &_swigt__p_TALLOC_CTX,
5792   &_swigt__p_char,
5793   &_swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
5794   &_swigt__p_int,
5795   &_swigt__p_ldb_context,
5796   &_swigt__p_ldb_dn,
5797   &_swigt__p_ldb_ldif,
5798   &_swigt__p_ldb_message,
5799   &_swigt__p_ldb_message_element,
5800   &_swigt__p_ldb_module_ops,
5801   &_swigt__p_ldb_result,
5802   &_swigt__p_ldb_val,
5803   &_swigt__p_long_long,
5804   &_swigt__p_p_char,
5805   &_swigt__p_p_ldb_control,
5806   &_swigt__p_p_ldb_result,
5807   &_swigt__p_short,
5808   &_swigt__p_signed_char,
5809   &_swigt__p_unsigned_char,
5810   &_swigt__p_unsigned_int,
5811   &_swigt__p_unsigned_long,
5812   &_swigt__p_unsigned_long_long,
5813   &_swigt__p_unsigned_short,
5814   &_swigt__p_void,
5815 };
5816
5817 static swig_cast_info _swigc__p_TALLOC_CTX[] = {  {&_swigt__p_TALLOC_CTX, 0, 0, 0},{0, 0, 0, 0}};
5818 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
5819 static swig_cast_info _swigc__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void[] = {  {&_swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void, 0, 0, 0},{0, 0, 0, 0}};
5820 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
5821 static swig_cast_info _swigc__p_ldb_context[] = {  {&_swigt__p_ldb_context, 0, 0, 0},{0, 0, 0, 0}};
5822 static swig_cast_info _swigc__p_ldb_dn[] = {  {&_swigt__p_ldb_dn, 0, 0, 0},{0, 0, 0, 0}};
5823 static swig_cast_info _swigc__p_ldb_ldif[] = {  {&_swigt__p_ldb_ldif, 0, 0, 0},{0, 0, 0, 0}};
5824 static swig_cast_info _swigc__p_ldb_message[] = {  {&_swigt__p_ldb_message, 0, 0, 0},{0, 0, 0, 0}};
5825 static swig_cast_info _swigc__p_ldb_message_element[] = {  {&_swigt__p_ldb_message_element, 0, 0, 0},{0, 0, 0, 0}};
5826 static swig_cast_info _swigc__p_ldb_module_ops[] = {  {&_swigt__p_ldb_module_ops, 0, 0, 0},{0, 0, 0, 0}};
5827 static swig_cast_info _swigc__p_ldb_result[] = {  {&_swigt__p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
5828 static swig_cast_info _swigc__p_ldb_val[] = {  {&_swigt__p_ldb_val, 0, 0, 0},{0, 0, 0, 0}};
5829 static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
5830 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
5831 static swig_cast_info _swigc__p_p_ldb_control[] = {  {&_swigt__p_p_ldb_control, 0, 0, 0},{0, 0, 0, 0}};
5832 static swig_cast_info _swigc__p_p_ldb_result[] = {  {&_swigt__p_p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
5833 static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
5834 static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
5835 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
5836 static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
5837 static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
5838 static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
5839 static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
5840 static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
5841
5842 static swig_cast_info *swig_cast_initial[] = {
5843   _swigc__p_TALLOC_CTX,
5844   _swigc__p_char,
5845   _swigc__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
5846   _swigc__p_int,
5847   _swigc__p_ldb_context,
5848   _swigc__p_ldb_dn,
5849   _swigc__p_ldb_ldif,
5850   _swigc__p_ldb_message,
5851   _swigc__p_ldb_message_element,
5852   _swigc__p_ldb_module_ops,
5853   _swigc__p_ldb_result,
5854   _swigc__p_ldb_val,
5855   _swigc__p_long_long,
5856   _swigc__p_p_char,
5857   _swigc__p_p_ldb_control,
5858   _swigc__p_p_ldb_result,
5859   _swigc__p_short,
5860   _swigc__p_signed_char,
5861   _swigc__p_unsigned_char,
5862   _swigc__p_unsigned_int,
5863   _swigc__p_unsigned_long,
5864   _swigc__p_unsigned_long_long,
5865   _swigc__p_unsigned_short,
5866   _swigc__p_void,
5867 };
5868
5869
5870 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
5871
5872 static swig_const_info swig_const_table[] = {
5873 {0, 0, 0, 0.0, 0, 0}};
5874
5875 #ifdef __cplusplus
5876 }
5877 #endif
5878 /* -----------------------------------------------------------------------------
5879  * Type initialization:
5880  * This problem is tough by the requirement that no dynamic
5881  * memory is used. Also, since swig_type_info structures store pointers to
5882  * swig_cast_info structures and swig_cast_info structures store pointers back
5883  * to swig_type_info structures, we need some lookup code at initialization.
5884  * The idea is that swig generates all the structures that are needed.
5885  * The runtime then collects these partially filled structures.
5886  * The SWIG_InitializeModule function takes these initial arrays out of
5887  * swig_module, and does all the lookup, filling in the swig_module.types
5888  * array with the correct data and linking the correct swig_cast_info
5889  * structures together.
5890  *
5891  * The generated swig_type_info structures are assigned staticly to an initial
5892  * array. We just loop through that array, and handle each type individually.
5893  * First we lookup if this type has been already loaded, and if so, use the
5894  * loaded structure instead of the generated one. Then we have to fill in the
5895  * cast linked list. The cast data is initially stored in something like a
5896  * two-dimensional array. Each row corresponds to a type (there are the same
5897  * number of rows as there are in the swig_type_initial array). Each entry in
5898  * a column is one of the swig_cast_info structures for that type.
5899  * The cast_initial array is actually an array of arrays, because each row has
5900  * a variable number of columns. So to actually build the cast linked list,
5901  * we find the array of casts associated with the type, and loop through it
5902  * adding the casts to the list. The one last trick we need to do is making
5903  * sure the type pointer in the swig_cast_info struct is correct.
5904  *
5905  * First off, we lookup the cast->type name to see if it is already loaded.
5906  * There are three cases to handle:
5907  *  1) If the cast->type has already been loaded AND the type we are adding
5908  *     casting info to has not been loaded (it is in this module), THEN we
5909  *     replace the cast->type pointer with the type pointer that has already
5910  *     been loaded.
5911  *  2) If BOTH types (the one we are adding casting info to, and the
5912  *     cast->type) are loaded, THEN the cast info has already been loaded by
5913  *     the previous module so we just ignore it.
5914  *  3) Finally, if cast->type has not already been loaded, then we add that
5915  *     swig_cast_info to the linked list (because the cast->type) pointer will
5916  *     be correct.
5917  * ----------------------------------------------------------------------------- */
5918
5919 #ifdef __cplusplus
5920 extern "C" {
5921 #if 0
5922 } /* c-mode */
5923 #endif
5924 #endif
5925
5926 #if 0
5927 #define SWIGRUNTIME_DEBUG
5928 #endif
5929
5930
5931 SWIGRUNTIME void
5932 SWIG_InitializeModule(void *clientdata) {
5933   size_t i;
5934   swig_module_info *module_head, *iter;
5935   int found;
5936
5937   clientdata = clientdata;
5938
5939   /* check to see if the circular list has been setup, if not, set it up */
5940   if (swig_module.next==0) {
5941     /* Initialize the swig_module */
5942     swig_module.type_initial = swig_type_initial;
5943     swig_module.cast_initial = swig_cast_initial;
5944     swig_module.next = &swig_module;
5945   }
5946
5947   /* Try and load any already created modules */
5948   module_head = SWIG_GetModule(clientdata);
5949   if (!module_head) {
5950     /* This is the first module loaded for this interpreter */
5951     /* so set the swig module into the interpreter */
5952     SWIG_SetModule(clientdata, &swig_module);
5953     module_head = &swig_module;
5954   } else {
5955     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
5956     found=0;
5957     iter=module_head;
5958     do {
5959       if (iter==&swig_module) {
5960         found=1;
5961         break;
5962       }
5963       iter=iter->next;
5964     } while (iter!= module_head);
5965
5966     /* if the is found in the list, then all is done and we may leave */
5967     if (found) return;
5968     /* otherwise we must add out module into the list */
5969     swig_module.next = module_head->next;
5970     module_head->next = &swig_module;
5971   }
5972
5973   /* Now work on filling in swig_module.types */
5974 #ifdef SWIGRUNTIME_DEBUG
5975   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
5976 #endif
5977   for (i = 0; i < swig_module.size; ++i) {
5978     swig_type_info *type = 0;
5979     swig_type_info *ret;
5980     swig_cast_info *cast;
5981
5982 #ifdef SWIGRUNTIME_DEBUG
5983     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
5984 #endif
5985
5986     /* if there is another module already loaded */
5987     if (swig_module.next != &swig_module) {
5988       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
5989     }
5990     if (type) {
5991       /* Overwrite clientdata field */
5992 #ifdef SWIGRUNTIME_DEBUG
5993       printf("SWIG_InitializeModule: found type %s\n", type->name);
5994 #endif
5995       if (swig_module.type_initial[i]->clientdata) {
5996         type->clientdata = swig_module.type_initial[i]->clientdata;
5997 #ifdef SWIGRUNTIME_DEBUG
5998         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
5999 #endif
6000       }
6001     } else {
6002       type = swig_module.type_initial[i];
6003     }
6004
6005     /* Insert casting types */
6006     cast = swig_module.cast_initial[i];
6007     while (cast->type) {
6008       /* Don't need to add information already in the list */
6009       ret = 0;
6010 #ifdef SWIGRUNTIME_DEBUG
6011       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
6012 #endif
6013       if (swig_module.next != &swig_module) {
6014         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
6015 #ifdef SWIGRUNTIME_DEBUG
6016         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
6017 #endif
6018       }
6019       if (ret) {
6020         if (type == swig_module.type_initial[i]) {
6021 #ifdef SWIGRUNTIME_DEBUG
6022           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
6023 #endif
6024           cast->type = ret;
6025           ret = 0;
6026         } else {
6027           /* Check for casting already in the list */
6028           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
6029 #ifdef SWIGRUNTIME_DEBUG
6030           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
6031 #endif
6032           if (!ocast) ret = 0;
6033         }
6034       }
6035
6036       if (!ret) {
6037 #ifdef SWIGRUNTIME_DEBUG
6038         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
6039 #endif
6040         if (type->cast) {
6041           type->cast->prev = cast;
6042           cast->next = type->cast;
6043         }
6044         type->cast = cast;
6045       }
6046       cast++;
6047     }
6048     /* Set entry in modules->types array equal to the type */
6049     swig_module.types[i] = type;
6050   }
6051   swig_module.types[i] = 0;
6052
6053 #ifdef SWIGRUNTIME_DEBUG
6054   printf("**** SWIG_InitializeModule: Cast List ******\n");
6055   for (i = 0; i < swig_module.size; ++i) {
6056     int j = 0;
6057     swig_cast_info *cast = swig_module.cast_initial[i];
6058     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6059     while (cast->type) {
6060       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
6061       cast++;
6062       ++j;
6063     }
6064     printf("---- Total casts: %d\n",j);
6065   }
6066   printf("**** SWIG_InitializeModule: Cast List ******\n");
6067 #endif
6068 }
6069
6070 /* This function will propagate the clientdata field of type to
6071 * any new swig_type_info structures that have been added into the list
6072 * of equivalent types.  It is like calling
6073 * SWIG_TypeClientData(type, clientdata) a second time.
6074 */
6075 SWIGRUNTIME void
6076 SWIG_PropagateClientData(void) {
6077   size_t i;
6078   swig_cast_info *equiv;
6079   static int init_run = 0;
6080
6081   if (init_run) return;
6082   init_run = 1;
6083
6084   for (i = 0; i < swig_module.size; i++) {
6085     if (swig_module.types[i]->clientdata) {
6086       equiv = swig_module.types[i]->cast;
6087       while (equiv) {
6088         if (!equiv->converter) {
6089           if (equiv->type && !equiv->type->clientdata)
6090           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
6091         }
6092         equiv = equiv->next;
6093       }
6094     }
6095   }
6096 }
6097
6098 #ifdef __cplusplus
6099 #if 0
6100 {
6101   /* c-mode */
6102 #endif
6103 }
6104 #endif
6105
6106
6107
6108 #ifdef __cplusplus
6109 extern "C" {
6110 #endif
6111
6112   /* Python-specific SWIG API */
6113 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
6114 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
6115 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
6116
6117   /* -----------------------------------------------------------------------------
6118    * global variable support code.
6119    * ----------------------------------------------------------------------------- */
6120
6121   typedef struct swig_globalvar {
6122     char       *name;                  /* Name of global variable */
6123     PyObject *(*get_attr)(void);       /* Return the current value */
6124     int       (*set_attr)(PyObject *); /* Set the value */
6125     struct swig_globalvar *next;
6126   } swig_globalvar;
6127
6128   typedef struct swig_varlinkobject {
6129     PyObject_HEAD
6130     swig_globalvar *vars;
6131   } swig_varlinkobject;
6132
6133   SWIGINTERN PyObject *
6134   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
6135     return PyString_FromString("<Swig global variables>");
6136   }
6137
6138   SWIGINTERN PyObject *
6139   swig_varlink_str(swig_varlinkobject *v) {
6140     PyObject *str = PyString_FromString("(");
6141     swig_globalvar  *var;
6142     for (var = v->vars; var; var=var->next) {
6143       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
6144       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
6145     }
6146     PyString_ConcatAndDel(&str,PyString_FromString(")"));
6147     return str;
6148   }
6149
6150   SWIGINTERN int
6151   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
6152     PyObject *str = swig_varlink_str(v);
6153     fprintf(fp,"Swig global variables ");
6154     fprintf(fp,"%s\n", PyString_AsString(str));
6155     Py_DECREF(str);
6156     return 0;
6157   }
6158
6159   SWIGINTERN void
6160   swig_varlink_dealloc(swig_varlinkobject *v) {
6161     swig_globalvar *var = v->vars;
6162     while (var) {
6163       swig_globalvar *n = var->next;
6164       free(var->name);
6165       free(var);
6166       var = n;
6167     }
6168   }
6169
6170   SWIGINTERN PyObject *
6171   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
6172     PyObject *res = NULL;
6173     swig_globalvar *var = v->vars;
6174     while (var) {
6175       if (strcmp(var->name,n) == 0) {
6176         res = (*var->get_attr)();
6177         break;
6178       }
6179       var = var->next;
6180     }
6181     if (res == NULL && !PyErr_Occurred()) {
6182       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6183     }
6184     return res;
6185   }
6186
6187   SWIGINTERN int
6188   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
6189     int res = 1;
6190     swig_globalvar *var = v->vars;
6191     while (var) {
6192       if (strcmp(var->name,n) == 0) {
6193         res = (*var->set_attr)(p);
6194         break;
6195       }
6196       var = var->next;
6197     }
6198     if (res == 1 && !PyErr_Occurred()) {
6199       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6200     }
6201     return res;
6202   }
6203
6204   SWIGINTERN PyTypeObject*
6205   swig_varlink_type(void) {
6206     static char varlink__doc__[] = "Swig var link object";
6207     static PyTypeObject varlink_type;
6208     static int type_init = 0;
6209     if (!type_init) {
6210       const PyTypeObject tmp
6211       = {
6212         PyObject_HEAD_INIT(NULL)
6213         0,                                  /* Number of items in variable part (ob_size) */
6214         (char *)"swigvarlink",              /* Type name (tp_name) */
6215         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
6216         0,                                  /* Itemsize (tp_itemsize) */
6217         (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */
6218         (printfunc) swig_varlink_print,     /* Print (tp_print) */
6219         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
6220         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
6221         0,                                  /* tp_compare */
6222         (reprfunc) swig_varlink_repr,       /* tp_repr */
6223         0,                                  /* tp_as_number */
6224         0,                                  /* tp_as_sequence */
6225         0,                                  /* tp_as_mapping */
6226         0,                                  /* tp_hash */
6227         0,                                  /* tp_call */
6228         (reprfunc)swig_varlink_str,        /* tp_str */
6229         0,                                  /* tp_getattro */
6230         0,                                  /* tp_setattro */
6231         0,                                  /* tp_as_buffer */
6232         0,                                  /* tp_flags */
6233         varlink__doc__,                     /* tp_doc */
6234         0,                                  /* tp_traverse */
6235         0,                                  /* tp_clear */
6236         0,                                  /* tp_richcompare */
6237         0,                                  /* tp_weaklistoffset */
6238 #if PY_VERSION_HEX >= 0x02020000
6239         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
6240 #endif
6241 #if PY_VERSION_HEX >= 0x02030000
6242         0,                                  /* tp_del */
6243 #endif
6244 #ifdef COUNT_ALLOCS
6245         0,0,0,0                             /* tp_alloc -> tp_next */
6246 #endif
6247       };
6248       varlink_type = tmp;
6249       varlink_type.ob_type = &PyType_Type;
6250       type_init = 1;
6251     }
6252     return &varlink_type;
6253   }
6254
6255   /* Create a variable linking object for use later */
6256   SWIGINTERN PyObject *
6257   SWIG_Python_newvarlink(void) {
6258     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
6259     if (result) {
6260       result->vars = 0;
6261     }
6262     return ((PyObject*) result);
6263   }
6264
6265   SWIGINTERN void
6266   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
6267     swig_varlinkobject *v = (swig_varlinkobject *) p;
6268     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
6269     if (gv) {
6270       size_t size = strlen(name)+1;
6271       gv->name = (char *)malloc(size);
6272       if (gv->name) {
6273         strncpy(gv->name,name,size);
6274         gv->get_attr = get_attr;
6275         gv->set_attr = set_attr;
6276         gv->next = v->vars;
6277       }
6278     }
6279     v->vars = gv;
6280   }
6281
6282   SWIGINTERN PyObject *
6283   SWIG_globals(void) {
6284     static PyObject *_SWIG_globals = 0;
6285     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
6286     return _SWIG_globals;
6287   }
6288
6289   /* -----------------------------------------------------------------------------
6290    * constants/methods manipulation
6291    * ----------------------------------------------------------------------------- */
6292
6293   /* Install Constants */
6294   SWIGINTERN void
6295   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
6296     PyObject *obj = 0;
6297     size_t i;
6298     for (i = 0; constants[i].type; ++i) {
6299       switch(constants[i].type) {
6300       case SWIG_PY_POINTER:
6301         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
6302         break;
6303       case SWIG_PY_BINARY:
6304         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
6305         break;
6306       default:
6307         obj = 0;
6308         break;
6309       }
6310       if (obj) {
6311         PyDict_SetItemString(d, constants[i].name, obj);
6312         Py_DECREF(obj);
6313       }
6314     }
6315   }
6316
6317   /* -----------------------------------------------------------------------------*/
6318   /* Fix SwigMethods to carry the callback ptrs when needed */
6319   /* -----------------------------------------------------------------------------*/
6320
6321   SWIGINTERN void
6322   SWIG_Python_FixMethods(PyMethodDef *methods,
6323     swig_const_info *const_table,
6324     swig_type_info **types,
6325     swig_type_info **types_initial) {
6326     size_t i;
6327     for (i = 0; methods[i].ml_name; ++i) {
6328       const char *c = methods[i].ml_doc;
6329       if (c && (c = strstr(c, "swig_ptr: "))) {
6330         int j;
6331         swig_const_info *ci = 0;
6332         const char *name = c + 10;
6333         for (j = 0; const_table[j].type; ++j) {
6334           if (strncmp(const_table[j].name, name,
6335               strlen(const_table[j].name)) == 0) {
6336             ci = &(const_table[j]);
6337             break;
6338           }
6339         }
6340         if (ci) {
6341           size_t shift = (ci->ptype) - types;
6342           swig_type_info *ty = types_initial[shift];
6343           size_t ldoc = (c - methods[i].ml_doc);
6344           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
6345           char *ndoc = (char*)malloc(ldoc + lptr + 10);
6346           if (ndoc) {
6347             char *buff = ndoc;
6348             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
6349             if (ptr) {
6350               strncpy(buff, methods[i].ml_doc, ldoc);
6351               buff += ldoc;
6352               strncpy(buff, "swig_ptr: ", 10);
6353               buff += 10;
6354               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
6355               methods[i].ml_doc = ndoc;
6356             }
6357           }
6358         }
6359       }
6360     }
6361   }
6362
6363 #ifdef __cplusplus
6364 }
6365 #endif
6366
6367 /* -----------------------------------------------------------------------------*
6368  *  Partial Init method
6369  * -----------------------------------------------------------------------------*/
6370
6371 #ifdef __cplusplus
6372 extern "C"
6373 #endif
6374 SWIGEXPORT void SWIG_init(void) {
6375   PyObject *m, *d;
6376
6377   /* Fix SwigMethods to carry the callback ptrs when needed */
6378   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
6379
6380   m = Py_InitModule((char *) SWIG_name, SwigMethods);
6381   d = PyModule_GetDict(m);
6382
6383   SWIG_InitializeModule(0);
6384   SWIG_InstallConstants(d,swig_const_table);
6385
6386
6387   SWIG_Python_SetConstant(d, "SCOPE_DEFAULT",SWIG_From_int((int)(LDB_SCOPE_DEFAULT)));
6388   SWIG_Python_SetConstant(d, "SCOPE_BASE",SWIG_From_int((int)(LDB_SCOPE_BASE)));
6389   SWIG_Python_SetConstant(d, "SCOPE_ONELEVEL",SWIG_From_int((int)(LDB_SCOPE_ONELEVEL)));
6390   SWIG_Python_SetConstant(d, "SCOPE_SUBTREE",SWIG_From_int((int)(LDB_SCOPE_SUBTREE)));
6391   SWIG_Python_SetConstant(d, "CHANGETYPE_NONE",SWIG_From_int((int)(LDB_CHANGETYPE_NONE)));
6392   SWIG_Python_SetConstant(d, "CHANGETYPE_ADD",SWIG_From_int((int)(LDB_CHANGETYPE_ADD)));
6393   SWIG_Python_SetConstant(d, "CHANGETYPE_DELETE",SWIG_From_int((int)(LDB_CHANGETYPE_DELETE)));
6394   SWIG_Python_SetConstant(d, "CHANGETYPE_MODIFY",SWIG_From_int((int)(LDB_CHANGETYPE_MODIFY)));
6395
6396   PyExc_LdbError = PyErr_NewException((char *)"_ldb.LdbError", NULL, NULL);
6397   PyDict_SetItemString(d, "LdbError", PyExc_LdbError);
6398
6399   SWIG_Python_SetConstant(d, "LDB_ERR_OPERATIONS_ERROR",SWIG_From_int((int)(1)));
6400   SWIG_Python_SetConstant(d, "LDB_ERR_PROTOCOL_ERROR",SWIG_From_int((int)(2)));
6401   SWIG_Python_SetConstant(d, "LDB_ERR_TIME_LIMIT_EXCEEDED",SWIG_From_int((int)(3)));
6402   SWIG_Python_SetConstant(d, "LDB_ERR_SIZE_LIMIT_EXCEEDED",SWIG_From_int((int)(4)));
6403   SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_FALSE",SWIG_From_int((int)(5)));
6404   SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_TRUE",SWIG_From_int((int)(6)));
6405   SWIG_Python_SetConstant(d, "LDB_ERR_AUTH_METHOD_NOT_SUPPORTED",SWIG_From_int((int)(7)));
6406   SWIG_Python_SetConstant(d, "LDB_ERR_STRONG_AUTH_REQUIRED",SWIG_From_int((int)(8)));
6407   SWIG_Python_SetConstant(d, "LDB_ERR_REFERRAL",SWIG_From_int((int)(10)));
6408   SWIG_Python_SetConstant(d, "LDB_ERR_ADMIN_LIMIT_EXCEEDED",SWIG_From_int((int)(11)));
6409   SWIG_Python_SetConstant(d, "LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION",SWIG_From_int((int)(12)));
6410   SWIG_Python_SetConstant(d, "LDB_ERR_CONFIDENTIALITY_REQUIRED",SWIG_From_int((int)(13)));
6411   SWIG_Python_SetConstant(d, "LDB_ERR_SASL_BIND_IN_PROGRESS",SWIG_From_int((int)(14)));
6412   SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_ATTRIBUTE",SWIG_From_int((int)(16)));
6413   SWIG_Python_SetConstant(d, "LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE",SWIG_From_int((int)(17)));
6414   SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_MATCHING",SWIG_From_int((int)(18)));
6415   SWIG_Python_SetConstant(d, "LDB_ERR_CONSTRAINT_VIOLATION",SWIG_From_int((int)(19)));
6416   SWIG_Python_SetConstant(d, "LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS",SWIG_From_int((int)(20)));
6417   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_ATTRIBUTE_SYNTAX",SWIG_From_int((int)(21)));
6418   SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_OBJECT",SWIG_From_int((int)(32)));
6419   SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_PROBLEM",SWIG_From_int((int)(33)));
6420   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_DN_SYNTAX",SWIG_From_int((int)(34)));
6421   SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_DEREFERENCING_PROBLEM",SWIG_From_int((int)(36)));
6422   SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_AUTHENTICATION",SWIG_From_int((int)(48)));
6423   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_CREDENTIALS",SWIG_From_int((int)(49)));
6424   SWIG_Python_SetConstant(d, "LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS",SWIG_From_int((int)(50)));
6425   SWIG_Python_SetConstant(d, "LDB_ERR_BUSY",SWIG_From_int((int)(51)));
6426   SWIG_Python_SetConstant(d, "LDB_ERR_UNAVAILABLE",SWIG_From_int((int)(52)));
6427   SWIG_Python_SetConstant(d, "LDB_ERR_UNWILLING_TO_PERFORM",SWIG_From_int((int)(53)));
6428   SWIG_Python_SetConstant(d, "LDB_ERR_LOOP_DETECT",SWIG_From_int((int)(54)));
6429   SWIG_Python_SetConstant(d, "LDB_ERR_NAMING_VIOLATION",SWIG_From_int((int)(64)));
6430   SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_VIOLATION",SWIG_From_int((int)(65)));
6431   SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_NON_LEAF",SWIG_From_int((int)(66)));
6432   SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_RDN",SWIG_From_int((int)(67)));
6433   SWIG_Python_SetConstant(d, "LDB_ERR_ENTRY_ALREADY_EXISTS",SWIG_From_int((int)(68)));
6434   SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED",SWIG_From_int((int)(69)));
6435   SWIG_Python_SetConstant(d, "LDB_ERR_AFFECTS_MULTIPLE_DSAS",SWIG_From_int((int)(71)));
6436   SWIG_Python_SetConstant(d, "LDB_ERR_OTHER",SWIG_From_int((int)(80)));
6437 }
6438