source4/lib/ldb/ldb_wrap.c

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