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             talloc_free(dn);
2736             return ret;
2737         }
2738 SWIGINTERN ldb_dn *ldb_dn___add__(ldb_dn *self,ldb_dn *other){
2739             ldb_dn *ret = ldb_dn_copy(NULL, self);
2740             ldb_dn_add_child(ret, other);
2741             return ret;
2742         }
2743
2744 struct ldb_context *ldb_context_from_py_object(PyObject *py_obj)
2745 {
2746         struct ldb_context *ldb_ctx;
2747     if (SWIG_ConvertPtr(py_obj, (void *)&ldb_ctx, SWIGTYPE_p_ldb_context, 0 |  0 ) < 0)
2748         return NULL;
2749     return ldb_ctx;
2750 }
2751
2752 int ldb_dn_from_pyobject(TALLOC_CTX *mem_ctx, PyObject *object,
2753                          struct ldb_context *ldb_ctx, ldb_dn **dn)
2754 {
2755     int ret;
2756     struct ldb_dn *odn;
2757     if (ldb_ctx != NULL && PyString_Check(object)) {
2758         odn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object));
2759         if (!odn) {
2760                 return SWIG_ERROR;
2761         }
2762         *dn = odn;
2763         return 0;
2764     }
2765     ret = SWIG_ConvertPtr(object, (void **)&odn, SWIGTYPE_p_ldb_dn,
2766                            SWIG_POINTER_EXCEPTION);
2767     *dn = ldb_dn_copy(mem_ctx, odn);
2768     if (odn && !*dn) {
2769         return SWIG_ERROR;
2770     }
2771     return ret;
2772 }
2773
2774 ldb_message_element *ldb_msg_element_from_pyobject(TALLOC_CTX *mem_ctx,
2775                                                PyObject *set_obj, int flags,
2776                                                const char *attr_name)
2777 {
2778     struct ldb_message_element *me = talloc(mem_ctx, struct ldb_message_element);
2779     me->name = attr_name;
2780     me->flags = flags;
2781     if (PyString_Check(set_obj)) {
2782         me->num_values = 1;
2783         me->values = talloc_array(me, struct ldb_val, me->num_values);
2784         me->values[0].length = PyString_Size(set_obj);
2785         me->values[0].data = (uint8_t *)talloc_strdup(me->values,
2786                                            PyString_AsString(set_obj));
2787     } else if (PySequence_Check(set_obj)) {
2788         int i;
2789         me->num_values = PySequence_Size(set_obj);
2790         me->values = talloc_array(me, struct ldb_val, me->num_values);
2791         for (i = 0; i < me->num_values; i++) {
2792             PyObject *obj = PySequence_GetItem(set_obj, i);
2793             me->values[i].length = PyString_Size(obj);
2794             me->values[i].data = (uint8_t *)PyString_AsString(obj);
2795         }
2796     } else {
2797         talloc_free(me);
2798         me = NULL;
2799     }
2800
2801     return me;
2802 }
2803
2804 PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx,
2805                                  ldb_message_element *me)
2806 {
2807     int i;
2808     PyObject *result;
2809
2810     /* Python << 2.5 doesn't have PySet_New and PySet_Add. */
2811     result = PyList_New(me->num_values);
2812
2813     for (i = 0; i < me->num_values; i++) {
2814         PyList_SetItem(result, i,
2815             ldb_val_to_py_object(ldb_ctx, me, &me->values[i]));
2816     }
2817
2818     return result;
2819 }
2820
2821
2822 SWIGINTERN int ldb_message_element___cmp__(ldb_message_element *self,ldb_message_element *other){
2823             return ldb_msg_element_compare(self, other);
2824         }
2825 SWIGINTERN PyObject *ldb_message_element___iter__(ldb_message_element *self){
2826             return PyObject_GetIter(ldb_msg_element_to_set(NULL, self));
2827         }
2828 SWIGINTERN PyObject *ldb_message_element___set__(ldb_message_element *self){
2829             return ldb_msg_element_to_set(NULL, self);
2830         }
2831
2832 #include <limits.h>
2833 #if !defined(SWIG_NO_LLONG_MAX)
2834 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2835 #   define LLONG_MAX __LONG_LONG_MAX__
2836 #   define LLONG_MIN (-LLONG_MAX - 1LL)
2837 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2838 # endif
2839 #endif
2840
2841
2842 SWIGINTERN int
2843 SWIG_AsVal_double (PyObject *obj, double *val)
2844 {
2845   int res = SWIG_TypeError;
2846   if (PyFloat_Check(obj)) {
2847     if (val) *val = PyFloat_AsDouble(obj);
2848     return SWIG_OK;
2849   } else if (PyInt_Check(obj)) {
2850     if (val) *val = PyInt_AsLong(obj);
2851     return SWIG_OK;
2852   } else if (PyLong_Check(obj)) {
2853     double v = PyLong_AsDouble(obj);
2854     if (!PyErr_Occurred()) {
2855       if (val) *val = v;
2856       return SWIG_OK;
2857     } else {
2858       PyErr_Clear();
2859     }
2860   }
2861 #ifdef SWIG_PYTHON_CAST_MODE
2862   {
2863     int dispatch = 0;
2864     double d = PyFloat_AsDouble(obj);
2865     if (!PyErr_Occurred()) {
2866       if (val) *val = d;
2867       return SWIG_AddCast(SWIG_OK);
2868     } else {
2869       PyErr_Clear();
2870     }
2871     if (!dispatch) {
2872       long v = PyLong_AsLong(obj);
2873       if (!PyErr_Occurred()) {
2874         if (val) *val = v;
2875         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2876       } else {
2877         PyErr_Clear();
2878       }
2879     }
2880   }
2881 #endif
2882   return res;
2883 }
2884
2885
2886 #include <float.h>
2887
2888
2889 #include <math.h>
2890
2891
2892 SWIGINTERNINLINE int
2893 SWIG_CanCastAsInteger(double *d, double min, double max) {
2894   double x = *d;
2895   if ((min <= x && x <= max)) {
2896    double fx = floor(x);
2897    double cx = ceil(x);
2898    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2899    if ((errno == EDOM) || (errno == ERANGE)) {
2900      errno = 0;
2901    } else {
2902      double summ, reps, diff;
2903      if (rd < x) {
2904        diff = x - rd;
2905      } else if (rd > x) {
2906        diff = rd - x;
2907      } else {
2908        return 1;
2909      }
2910      summ = rd + x;
2911      reps = diff/summ;
2912      if (reps < 8*DBL_EPSILON) {
2913        *d = rd;
2914        return 1;
2915      }
2916    }
2917   }
2918   return 0;
2919 }
2920
2921
2922 SWIGINTERN int
2923 SWIG_AsVal_long (PyObject *obj, long* val)
2924 {
2925   if (PyInt_Check(obj)) {
2926     if (val) *val = PyInt_AsLong(obj);
2927     return SWIG_OK;
2928   } else if (PyLong_Check(obj)) {
2929     long v = PyLong_AsLong(obj);
2930     if (!PyErr_Occurred()) {
2931       if (val) *val = v;
2932       return SWIG_OK;
2933     } else {
2934       PyErr_Clear();
2935     }
2936   }
2937 #ifdef SWIG_PYTHON_CAST_MODE
2938   {
2939     int dispatch = 0;
2940     long v = PyInt_AsLong(obj);
2941     if (!PyErr_Occurred()) {
2942       if (val) *val = v;
2943       return SWIG_AddCast(SWIG_OK);
2944     } else {
2945       PyErr_Clear();
2946     }
2947     if (!dispatch) {
2948       double d;
2949       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2950       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2951         if (val) *val = (long)(d);
2952         return res;
2953       }
2954     }
2955   }
2956 #endif
2957   return SWIG_TypeError;
2958 }
2959
2960
2961 SWIGINTERN int
2962 SWIG_AsVal_int (PyObject * obj, int *val)
2963 {
2964   long v;
2965   int res = SWIG_AsVal_long (obj, &v);
2966   if (SWIG_IsOK(res)) {
2967     if ((v < INT_MIN || v > INT_MAX)) {
2968       return SWIG_OverflowError;
2969     } else {
2970       if (val) *val = (int)(v);
2971     }
2972   }
2973   return res;
2974 }
2975
2976 SWIGINTERN ldb_message_element *new_ldb_message_element(PyObject *set_obj,int flags,char const *name){
2977             return ldb_msg_element_from_pyobject(NULL, set_obj, flags, name);
2978         }
2979 SWIGINTERN int ldb_message_element___len__(ldb_message_element *self){
2980             return self->num_values;
2981         }
2982 SWIGINTERN PyObject *ldb_message_element_get(ldb_message_element *self,int i){
2983             if (i < 0 || i >= self->num_values)
2984                 return Py_None;
2985
2986             return ldb_val_to_py_object(NULL, self, &self->values[i]);
2987         }
2988 SWIGINTERN void delete_ldb_message_element(ldb_message_element *self){ talloc_free(self); }
2989
2990     PyObject *ldb_msg_list_elements(ldb_msg *msg)
2991     {
2992         int i, j = 0;
2993         PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
2994         if (msg->dn != NULL) {
2995             PyList_SetItem(obj, j, PyString_FromString("dn"));
2996             j++;
2997         }
2998         for (i = 0; i < msg->num_elements; i++) {
2999             PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name));
3000             j++;
3001         }
3002         return obj;
3003     }
3004
3005 SWIGINTERN ldb_msg *new_ldb_msg(ldb_dn *dn){
3006             ldb_msg *ret = ldb_msg_new(NULL);
3007             ret->dn = talloc_reference(ret, dn);
3008             return ret;
3009         }
3010 SWIGINTERN void delete_ldb_msg(ldb_msg *self){ talloc_free(self); }
3011 SWIGINTERN void ldb_msg___setitem____SWIG_0(ldb_msg *self,char const *attr_name,ldb_message_element *val){
3012             struct ldb_message_element *el;
3013
3014             ldb_msg_remove_attr(self, attr_name);
3015
3016             el = talloc(self, struct ldb_message_element);
3017             el->name = talloc_strdup(el, attr_name);
3018             el->num_values = val->num_values;
3019             el->values = talloc_reference(el, val->values);
3020
3021             ldb_msg_add(self, el, val->flags);
3022         }
3023 SWIGINTERN void ldb_msg___setitem____SWIG_1(ldb_msg *self,char const *attr_name,PyObject *val){
3024             struct ldb_message_element *el = ldb_msg_element_from_pyobject(NULL,
3025                                                 val, 0, attr_name);
3026             talloc_steal(self, el);
3027             ldb_msg_remove_attr(self, attr_name);
3028             ldb_msg_add(self, el, el->flags);
3029         }
3030 SWIGINTERN unsigned int ldb_msg___len__(ldb_msg *self){ return self->num_elements; }
3031
3032 SWIGINTERNINLINE PyObject*
3033 SWIG_From_unsigned_SS_long  (unsigned long value)
3034 {
3035   return (value > LONG_MAX) ?
3036     PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
3037 }
3038
3039
3040 SWIGINTERNINLINE PyObject *
3041 SWIG_From_unsigned_SS_int  (unsigned int value)
3042 {
3043   return SWIG_From_unsigned_SS_long  (value);
3044 }
3045
3046 SWIGINTERN PyObject *ldb_msg_keys(ldb_msg *self){
3047             return ldb_msg_list_elements(self);
3048         }
3049 SWIGINTERN PyObject *ldb_msg___iter__(ldb_msg *self){
3050             return PyObject_GetIter(ldb_msg_list_elements(self));
3051         }
3052
3053 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3, 0);
3054
3055 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
3056 {
3057     char *text;
3058     PyObject *fn = context;
3059
3060     vasprintf(&text, fmt, ap);
3061     PyObject_CallFunction(fn, (char *)"(i,s)", level, text);
3062     free(text);
3063 }
3064
3065
3066     static PyObject *ldb_ldif_to_pyobject(ldb_ldif *ldif)
3067     {
3068         if (ldif == NULL) {
3069             return Py_None;
3070         } else {
3071             return Py_BuildValue((char *)"(iO)", ldif->changetype,
3072                    SWIG_NewPointerObj(ldif->msg, SWIGTYPE_p_ldb_message, 0));
3073         }
3074     }
3075
3076
3077 PyObject *PyExc_LdbError;
3078
3079 SWIGINTERN ldb *new_ldb(){
3080             return ldb_init(NULL, event_context_init(NULL));
3081         }
3082
3083 SWIGINTERN int
3084 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3085 {
3086   if (PyInt_Check(obj)) {
3087     long v = PyInt_AsLong(obj);
3088     if (v >= 0) {
3089       if (val) *val = v;
3090       return SWIG_OK;
3091     } else {
3092       return SWIG_OverflowError;
3093     }
3094   } else if (PyLong_Check(obj)) {
3095     unsigned long v = PyLong_AsUnsignedLong(obj);
3096     if (!PyErr_Occurred()) {
3097       if (val) *val = v;
3098       return SWIG_OK;
3099     } else {
3100       PyErr_Clear();
3101     }
3102   }
3103 #ifdef SWIG_PYTHON_CAST_MODE
3104   {
3105     int dispatch = 0;
3106     unsigned long v = PyLong_AsUnsignedLong(obj);
3107     if (!PyErr_Occurred()) {
3108       if (val) *val = v;
3109       return SWIG_AddCast(SWIG_OK);
3110     } else {
3111       PyErr_Clear();
3112     }
3113     if (!dispatch) {
3114       double d;
3115       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3116       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3117         if (val) *val = (unsigned long)(d);
3118         return res;
3119       }
3120     }
3121   }
3122 #endif
3123   return SWIG_TypeError;
3124 }
3125
3126
3127 SWIGINTERN int
3128 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3129 {
3130   unsigned long v;
3131   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3132   if (SWIG_IsOK(res)) {
3133     if ((v > UINT_MAX)) {
3134       return SWIG_OverflowError;
3135     } else {
3136       if (val) *val = (unsigned int)(v);
3137     }
3138   }
3139   return res;
3140 }
3141
3142 SWIGINTERN void delete_ldb(ldb *self){ talloc_free(self); }
3143 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){
3144             int ret;
3145             struct ldb_result *res;
3146             struct ldb_request *req;
3147             res = talloc_zero(mem_ctx, struct ldb_result);
3148             if (!res) {
3149                 return 1;
3150             }
3151
3152             ret = ldb_build_search_req(&req, self, mem_ctx,
3153                            base?base:ldb_get_default_basedn(self),
3154                            scope,
3155                            expression,
3156                            attrs,
3157                            controls,
3158                            res,
3159                            ldb_search_default_callback);
3160
3161             if (ret != 0) {
3162                 talloc_free(res);
3163                 return ret;
3164             }
3165
3166             ldb_set_timeout(self, req, 0); /* use default timeout */
3167
3168             ret = ldb_request(self, req);
3169
3170             if (ret == 0) {
3171                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
3172             }
3173
3174             talloc_free(req);
3175
3176             *OUT = res;
3177             return ret;
3178         }
3179 SWIGINTERN PyObject *ldb_schema_format_value(ldb *self,char const *element_name,PyObject *val){
3180                 const struct ldb_schema_attribute *a;
3181                 struct ldb_val old_val;
3182                 struct ldb_val new_val;
3183                 TALLOC_CTX *mem_ctx = talloc_new(NULL);
3184                 PyObject *ret;
3185
3186                 old_val.data = PyString_AsString(val);
3187                 old_val.length = PyString_Size(val);
3188
3189                 a = ldb_schema_attribute_by_name(self, element_name);
3190
3191                 if (a == NULL) {
3192                         return Py_None;
3193                 }
3194
3195                 if (a->syntax->ldif_write_fn(self, mem_ctx, &old_val, &new_val) != 0) {
3196                         talloc_free(mem_ctx);
3197                         return Py_None;
3198                  }
3199
3200                 ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
3201
3202                 talloc_free(mem_ctx);
3203
3204                 return ret;
3205         }
3206 SWIGINTERN ldb_error ldb___contains__(ldb *self,ldb_dn *dn,struct ldb_result **result_as_bool){
3207             return ldb_search(self, self, result_as_bool,
3208                               dn, LDB_SCOPE_BASE, NULL, NULL);
3209         }
3210 SWIGINTERN PyObject *ldb_parse_ldif(ldb *self,char const *s){
3211             PyObject *list = PyList_New(0);
3212             struct ldb_ldif *ldif;
3213             while ((ldif = ldb_ldif_read_string(self, &s)) != NULL) {
3214                 PyList_Append(list, ldb_ldif_to_pyobject(ldif));
3215             }
3216             return PyObject_GetIter(list);
3217         }
3218 SWIGINTERN char *ldb___repr__(ldb *self){
3219             char *ret;
3220             asprintf(&ret, "<ldb connection at 0x%x>", ret);
3221             return ret;
3222         }
3223
3224 static char *timestring(time_t t)
3225 {
3226     char *tresult = ldb_timestring(NULL, t);
3227     char *result = strdup(tresult);
3228     talloc_free(tresult);
3229     return result;
3230 }
3231
3232 SWIGINTERN char const *ldb_module___str__(ldb_module *self){
3233             return self->ops->name;
3234         }
3235 SWIGINTERN char *ldb_module___repr__(ldb_module *self){
3236             char *ret;
3237             asprintf(&ret, "<ldb module '%s'>", self->ops->name);
3238             return ret;
3239         }
3240 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){
3241             int ret;
3242             struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
3243
3244             req->operation = LDB_SEARCH;
3245             req->op.search.base = base;
3246             req->op.search.scope = scope;
3247             req->op.search.tree = tree;
3248             req->op.search.attrs = attrs;
3249
3250             req->op.search.res = talloc_zero(NULL, struct ldb_result);
3251
3252             ret = self->ops->search(self, req);
3253
3254             *res = req->op.search.res;
3255
3256             talloc_free(req);
3257
3258             return ret;
3259         }
3260 SWIGINTERN ldb_error ldb_module_add(ldb_module *self,struct ldb_message *message){
3261             struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
3262             req->operation = LDB_ADD;
3263             req->op.add.message = message;
3264
3265             return self->ops->add(self, &req);
3266         }
3267 SWIGINTERN ldb_error ldb_module_modify(ldb_module *self,struct ldb_message *message){
3268             struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
3269             req->operation = LDB_MODIFY;
3270             req->op.mod.message = message;
3271
3272             return self->ops->modify(self, &req);
3273         }
3274 SWIGINTERN ldb_error ldb_module_delete(ldb_module *self,struct ldb_dn *dn){
3275             struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
3276             req->operation = LDB_DELETE;
3277             req->op.del.dn = dn;
3278
3279             return self->ops->del(self, &req);
3280
3281         }
3282 SWIGINTERN ldb_error ldb_module_rename(ldb_module *self,struct ldb_dn *olddn,struct ldb_dn *newdn){
3283             struct ldb_request *req = talloc_zero(NULL, struct ldb_request);
3284             req->operation = LDB_RENAME;
3285             req->op.rename.olddn = olddn;
3286             req->op.rename.olddn = newdn;
3287
3288             return self->ops->rename(self, &req);
3289         }
3290 SWIGINTERN ldb_error ldb_module_start_transaction(ldb_module *self){
3291             return self->ops->start_transaction(self);
3292         }
3293 SWIGINTERN ldb_error ldb_module_end_transaction(ldb_module *self){
3294             return self->ops->end_transaction(self);
3295         }
3296 SWIGINTERN ldb_error ldb_module_del_transaction(ldb_module *self){
3297             return self->ops->del_transaction(self);
3298         }
3299
3300 int py_module_search(struct ldb_module *mod, struct ldb_request *req)
3301 {
3302     PyObject *py_ldb = mod->private_data;
3303     PyObject *py_result, *py_base, *py_attrs, *py_tree;
3304
3305     py_base = SWIG_NewPointerObj(req->op.search.base, SWIGTYPE_p_ldb_dn, 0);
3306
3307     if (py_base == NULL)
3308         return LDB_ERR_OPERATIONS_ERROR;
3309
3310     py_tree = SWIG_NewPointerObj(req->op.search.tree, SWIGTYPE_p_ldb_parse_tree, 0);
3311
3312     if (py_tree == NULL)
3313         return LDB_ERR_OPERATIONS_ERROR;
3314
3315     if (req->op.search.attrs == NULL) {
3316         py_attrs = Py_None;
3317     } else {
3318         int i, len;
3319         for (len = 0; req->op.search.attrs[len]; len++);
3320         py_attrs = PyList_New(len);
3321         for (i = 0; i < len; i++)
3322             PyList_SetItem(py_attrs, i, PyString_FromString(req->op.search.attrs[i]));
3323     }
3324
3325     py_result = PyObject_CallMethod(py_ldb, "search", "OiOO", py_base, req->op.search.scope, py_tree, py_attrs);
3326
3327     Py_DECREF(py_attrs);
3328     Py_DECREF(py_tree);
3329     Py_DECREF(py_base);
3330
3331     if (py_result == NULL) {
3332         return LDB_ERR_OPERATIONS_ERROR;
3333     }
3334
3335     if (SWIG_ConvertPtr(py_result, &req->op.search.res, SWIGTYPE_p_ldb_result, 0) != 0) {
3336         return LDB_ERR_OPERATIONS_ERROR;
3337     }
3338
3339     Py_DECREF(py_result);
3340
3341     return LDB_SUCCESS;
3342 }
3343
3344 int py_module_add(struct ldb_module *mod, struct ldb_request *req)
3345 {
3346     PyObject *py_ldb = mod->private_data;
3347     PyObject *py_result, *py_msg;
3348
3349     py_msg = SWIG_NewPointerObj(req->op.add.message, SWIGTYPE_p_ldb_message, 0);
3350
3351     if (py_msg == NULL) {
3352         return LDB_ERR_OPERATIONS_ERROR;
3353     }
3354
3355     py_result = PyObject_CallMethod(py_ldb, "add", "O", py_msg);
3356
3357     Py_DECREF(py_msg);
3358
3359     if (py_result == NULL) {
3360         return LDB_ERR_OPERATIONS_ERROR;
3361     }
3362
3363     Py_DECREF(py_result);
3364
3365     return LDB_SUCCESS;
3366 }
3367
3368 int py_module_modify(struct ldb_module *mod, struct ldb_request *req)
3369 {
3370     PyObject *py_ldb = mod->private_data;
3371     PyObject *py_result, *py_msg;
3372
3373     py_msg = SWIG_NewPointerObj(req->op.mod.message, SWIGTYPE_p_ldb_message, 0);
3374
3375     if (py_msg == NULL) {
3376         return LDB_ERR_OPERATIONS_ERROR;
3377     }
3378
3379     py_result = PyObject_CallMethod(py_ldb, "modify", "O", py_msg);
3380
3381     Py_DECREF(py_msg);
3382
3383     if (py_result == NULL) {
3384         return LDB_ERR_OPERATIONS_ERROR;
3385     }
3386
3387     Py_DECREF(py_result);
3388
3389     return LDB_SUCCESS;
3390 }
3391
3392 int py_module_del(struct ldb_module *mod, struct ldb_request *req)
3393 {
3394     PyObject *py_ldb = mod->private_data;
3395     PyObject *py_result, *py_dn;
3396
3397     py_dn = SWIG_NewPointerObj(req->op.del.dn, SWIGTYPE_p_ldb_dn, 0);
3398
3399     if (py_dn == NULL)
3400         return LDB_ERR_OPERATIONS_ERROR;
3401
3402     py_result = PyObject_CallMethod(py_ldb, "delete", "O", py_dn);
3403
3404     if (py_result == NULL) {
3405         return LDB_ERR_OPERATIONS_ERROR;
3406     }
3407
3408     Py_DECREF(py_result);
3409
3410     return LDB_SUCCESS;
3411 }
3412
3413 int py_module_rename(struct ldb_module *mod, struct ldb_request *req)
3414 {
3415     PyObject *py_ldb = mod->private_data;
3416     PyObject *py_result, *py_olddn, *py_newdn;
3417
3418     py_olddn = SWIG_NewPointerObj(req->op.rename.olddn, SWIGTYPE_p_ldb_dn, 0);
3419
3420     if (py_olddn == NULL)
3421         return LDB_ERR_OPERATIONS_ERROR;
3422
3423     py_newdn = SWIG_NewPointerObj(req->op.rename.newdn, SWIGTYPE_p_ldb_dn, 0);
3424
3425     if (py_newdn == NULL)
3426         return LDB_ERR_OPERATIONS_ERROR;
3427
3428     py_result = PyObject_CallMethod(py_ldb, "rename", "OO", py_olddn, py_newdn);
3429
3430     Py_DECREF(py_olddn);
3431     Py_DECREF(py_newdn);
3432
3433     if (py_result == NULL) {
3434         return LDB_ERR_OPERATIONS_ERROR;
3435     }
3436
3437     Py_DECREF(py_result);
3438
3439     return LDB_SUCCESS;
3440 }
3441
3442 int py_module_request(struct ldb_module *mod, struct ldb_request *req)
3443 {
3444     PyObject *py_ldb = mod->private_data;
3445     PyObject *py_result;
3446
3447     py_result = PyObject_CallMethod(py_ldb, "request", "");
3448
3449     return LDB_ERR_OPERATIONS_ERROR;
3450 }
3451
3452 int py_module_extended(struct ldb_module *mod, struct ldb_request *req)
3453 {
3454     PyObject *py_ldb = mod->private_data;
3455     PyObject *py_result;
3456
3457     py_result = PyObject_CallMethod(py_ldb, "extended", "");
3458
3459     return LDB_ERR_OPERATIONS_ERROR;
3460 }
3461
3462 int py_module_start_transaction(struct ldb_module *mod)
3463 {
3464     PyObject *py_ldb = mod->private_data;
3465     PyObject *py_result;
3466
3467     py_result = PyObject_CallMethod(py_ldb, "start_transaction", "");
3468
3469     if (py_result == NULL) {
3470         return LDB_ERR_OPERATIONS_ERROR;
3471     }
3472
3473     Py_DECREF(py_result);
3474
3475     return LDB_SUCCESS;
3476 }
3477
3478 int py_module_end_transaction(struct ldb_module *mod)
3479 {
3480     PyObject *py_ldb = mod->private_data;
3481     PyObject *py_result;
3482
3483     py_result = PyObject_CallMethod(py_ldb, "end_transaction", "");
3484
3485     if (py_result == NULL) {
3486         return LDB_ERR_OPERATIONS_ERROR;
3487     }
3488
3489     Py_DECREF(py_result);
3490
3491     return LDB_SUCCESS;
3492 }
3493
3494 int py_module_del_transaction(struct ldb_module *mod)
3495 {
3496     PyObject *py_ldb = mod->private_data;
3497     PyObject *py_result;
3498
3499     py_result = PyObject_CallMethod(py_ldb, "del_transaction", "");
3500
3501     if (py_result == NULL) {
3502         return LDB_ERR_OPERATIONS_ERROR;
3503     }
3504
3505     Py_DECREF(py_result);
3506
3507     return LDB_SUCCESS;
3508 }
3509
3510 int py_module_wait(struct ldb_handle *mod, enum ldb_wait_type wait_type)
3511 {
3512     PyObject *py_ldb = mod->private_data;
3513     PyObject *py_result;
3514
3515     py_result = PyObject_CallMethod(py_ldb, "wait", "i", wait_type);
3516
3517     if (py_result == NULL) {
3518         return LDB_ERR_OPERATIONS_ERROR;
3519     }
3520
3521     Py_DECREF(py_result);
3522
3523     return LDB_SUCCESS;
3524 }
3525
3526 int py_module_sequence_number(struct ldb_module *mod, struct ldb_request *req)
3527 {
3528     PyObject *py_ldb = mod->private_data;
3529     PyObject *py_result;
3530     int ret;
3531
3532     py_result = PyObject_CallMethod(py_ldb, "sequence_number", "ili", req->op.seq_num.type, req->op.seq_num.seq_num, req->op.seq_num.flags);
3533
3534     if (py_result == NULL) {
3535         return LDB_ERR_OPERATIONS_ERROR;
3536     }
3537
3538     ret = PyInt_AsLong(py_result);
3539
3540     Py_DECREF(py_result);
3541
3542     return ret;
3543 }
3544
3545 static int py_module_destructor(void *_mod)
3546 {
3547     struct ldb_module *mod = _mod;
3548     Py_DECREF((PyObject *)mod->private_data);
3549     return 0;
3550 }
3551
3552 int py_module_init (struct ldb_module *mod)
3553 {
3554     PyObject *py_class = mod->ops->private_data;
3555     PyObject *py_result, *py_next, *py_ldb;
3556
3557     py_ldb = SWIG_NewPointerObj(mod->ldb, SWIGTYPE_p_ldb_context, 0);
3558
3559     if (py_ldb == NULL)
3560         return LDB_ERR_OPERATIONS_ERROR;
3561
3562     py_next = SWIG_NewPointerObj(mod->next, SWIGTYPE_p_ldb_module, 0);
3563
3564     if (py_next == NULL)
3565         return LDB_ERR_OPERATIONS_ERROR;
3566
3567     py_result = PyObject_CallFunction(py_class, "OO", py_ldb, py_next);
3568
3569     if (py_result == NULL) {
3570         return LDB_ERR_OPERATIONS_ERROR;
3571     }
3572
3573     mod->private_data = py_result;
3574
3575     talloc_set_destructor (mod, py_module_destructor);
3576
3577     return ldb_next_init(mod);
3578 }
3579
3580 #ifdef __cplusplus
3581 extern "C" {
3582 #endif
3583 SWIGINTERN PyObject *_wrap_ldb_val_to_py_object(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3584   PyObject *resultobj = 0;
3585   struct ldb_context *arg1 = (struct ldb_context *) 0 ;
3586   struct ldb_message_element *arg2 = (struct ldb_message_element *) 0 ;
3587   struct ldb_val *arg3 = (struct ldb_val *) 0 ;
3588   void *argp1 = 0 ;
3589   int res1 = 0 ;
3590   void *argp2 = 0 ;
3591   int res2 = 0 ;
3592   void *argp3 = 0 ;
3593   int res3 = 0 ;
3594   PyObject * obj0 = 0 ;
3595   PyObject * obj1 = 0 ;
3596   PyObject * obj2 = 0 ;
3597   char *  kwnames[] = {
3598     (char *) "ldb_ctx",(char *) "el",(char *) "val", NULL
3599   };
3600   PyObject *result = 0 ;
3601
3602   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ldb_val_to_py_object",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3603   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
3604   if (!SWIG_IsOK(res1)) {
3605     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_val_to_py_object" "', argument " "1"" of type '" "struct ldb_context *""'");
3606   }
3607   arg1 = (struct ldb_context *)(argp1);
3608   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3609   if (!SWIG_IsOK(res2)) {
3610     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_val_to_py_object" "', argument " "2"" of type '" "struct ldb_message_element *""'");
3611   }
3612   arg2 = (struct ldb_message_element *)(argp2);
3613   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ldb_val, 0 |  0 );
3614   if (!SWIG_IsOK(res3)) {
3615     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ldb_val_to_py_object" "', argument " "3"" of type '" "struct ldb_val *""'");
3616   }
3617   arg3 = (struct ldb_val *)(argp3);
3618   if (arg1 == NULL)
3619   SWIG_exception(SWIG_ValueError,
3620     "ldb context must be non-NULL");
3621   result = (PyObject *)ldb_val_to_py_object(arg1,arg2,arg3);
3622   resultobj = result;
3623   return resultobj;
3624 fail:
3625   return NULL;
3626 }
3627
3628
3629 SWIGINTERN PyObject *_wrap_new_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3630   PyObject *resultobj = 0;
3631   ldb *arg1 = (ldb *) 0 ;
3632   char *arg2 = (char *) 0 ;
3633   void *argp1 = 0 ;
3634   int res1 = 0 ;
3635   int res2 ;
3636   char *buf2 = 0 ;
3637   int alloc2 = 0 ;
3638   PyObject * obj0 = 0 ;
3639   PyObject * obj1 = 0 ;
3640   char *  kwnames[] = {
3641     (char *) "ldb_ctx",(char *) "str", NULL
3642   };
3643   ldb_dn *result = 0 ;
3644
3645   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Dn",kwnames,&obj0,&obj1)) SWIG_fail;
3646   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
3647   if (!SWIG_IsOK(res1)) {
3648     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Dn" "', argument " "1"" of type '" "ldb *""'");
3649   }
3650   arg1 = (ldb *)(argp1);
3651   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3652   if (!SWIG_IsOK(res2)) {
3653     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Dn" "', argument " "2"" of type '" "char const *""'");
3654   }
3655   arg2 = (char *)(buf2);
3656   if (arg1 == NULL)
3657   SWIG_exception(SWIG_ValueError,
3658     "ldb context must be non-NULL");
3659   result = (ldb_dn *)new_ldb_dn(arg1,(char const *)arg2);
3660   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, SWIG_POINTER_NEW |  0 );
3661   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3662   return resultobj;
3663 fail:
3664   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3665   return NULL;
3666 }
3667
3668
3669 SWIGINTERN PyObject *_wrap_delete_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3670   PyObject *resultobj = 0;
3671   ldb_dn *arg1 = (ldb_dn *) 0 ;
3672   void *argp1 = 0 ;
3673   int res1 = 0 ;
3674   PyObject *swig_obj[1] ;
3675
3676   if (!args) SWIG_fail;
3677   swig_obj[0] = args;
3678   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
3679   if (!SWIG_IsOK(res1)) {
3680     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dn" "', argument " "1"" of type '" "ldb_dn *""'");
3681   }
3682   arg1 = (ldb_dn *)(argp1);
3683   delete_ldb_dn(arg1);
3684   resultobj = SWIG_Py_Void();
3685   return resultobj;
3686 fail:
3687   return NULL;
3688 }
3689
3690
3691 SWIGINTERN PyObject *_wrap_Dn_validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3692   PyObject *resultobj = 0;
3693   ldb_dn *arg1 = (ldb_dn *) 0 ;
3694   void *argp1 = 0 ;
3695   int res1 = 0 ;
3696   PyObject *swig_obj[1] ;
3697   bool result;
3698
3699   if (!args) SWIG_fail;
3700   swig_obj[0] = args;
3701   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3702   if (!SWIG_IsOK(res1)) {
3703     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_validate" "', argument " "1"" of type '" "ldb_dn *""'");
3704   }
3705   arg1 = (ldb_dn *)(argp1);
3706   result = (bool)ldb_dn_validate(arg1);
3707   resultobj = SWIG_From_bool((bool)(result));
3708   return resultobj;
3709 fail:
3710   return NULL;
3711 }
3712
3713
3714 SWIGINTERN PyObject *_wrap_Dn_get_casefold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3715   PyObject *resultobj = 0;
3716   ldb_dn *arg1 = (ldb_dn *) 0 ;
3717   void *argp1 = 0 ;
3718   int res1 = 0 ;
3719   PyObject *swig_obj[1] ;
3720   char *result = 0 ;
3721
3722   if (!args) SWIG_fail;
3723   swig_obj[0] = args;
3724   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3725   if (!SWIG_IsOK(res1)) {
3726     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_get_casefold" "', argument " "1"" of type '" "ldb_dn *""'");
3727   }
3728   arg1 = (ldb_dn *)(argp1);
3729   result = (char *)ldb_dn_get_casefold(arg1);
3730   resultobj = SWIG_FromCharPtr((const char *)result);
3731   return resultobj;
3732 fail:
3733   return NULL;
3734 }
3735
3736
3737 SWIGINTERN PyObject *_wrap_Dn___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3738   PyObject *resultobj = 0;
3739   ldb_dn *arg1 = (ldb_dn *) 0 ;
3740   void *argp1 = 0 ;
3741   int res1 = 0 ;
3742   PyObject *swig_obj[1] ;
3743   char *result = 0 ;
3744
3745   if (!args) SWIG_fail;
3746   swig_obj[0] = args;
3747   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3748   if (!SWIG_IsOK(res1)) {
3749     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___str__" "', argument " "1"" of type '" "ldb_dn *""'");
3750   }
3751   arg1 = (ldb_dn *)(argp1);
3752   result = (char *)ldb_dn_get_linearized(arg1);
3753   resultobj = SWIG_FromCharPtr((const char *)result);
3754   return resultobj;
3755 fail:
3756   return NULL;
3757 }
3758
3759
3760 SWIGINTERN PyObject *_wrap_Dn_parent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3761   PyObject *resultobj = 0;
3762   ldb_dn *arg1 = (ldb_dn *) 0 ;
3763   void *argp1 = 0 ;
3764   int res1 = 0 ;
3765   PyObject *swig_obj[1] ;
3766   ldb_dn *result = 0 ;
3767
3768   if (!args) SWIG_fail;
3769   swig_obj[0] = args;
3770   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3771   if (!SWIG_IsOK(res1)) {
3772     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_parent" "', argument " "1"" of type '" "ldb_dn *""'");
3773   }
3774   arg1 = (ldb_dn *)(argp1);
3775   result = (ldb_dn *)ldb_dn_parent(arg1);
3776   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
3777   return resultobj;
3778 fail:
3779   return NULL;
3780 }
3781
3782
3783 SWIGINTERN PyObject *_wrap_Dn___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3784   PyObject *resultobj = 0;
3785   ldb_dn *arg1 = (ldb_dn *) 0 ;
3786   ldb_dn *arg2 = (ldb_dn *) 0 ;
3787   void *argp1 = 0 ;
3788   int res1 = 0 ;
3789   void *argp2 = 0 ;
3790   int res2 = 0 ;
3791   PyObject * obj0 = 0 ;
3792   PyObject * obj1 = 0 ;
3793   char *  kwnames[] = {
3794     (char *) "self",(char *) "other", NULL
3795   };
3796   int result;
3797
3798   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
3799   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3800   if (!SWIG_IsOK(res1)) {
3801     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___cmp__" "', argument " "1"" of type '" "ldb_dn *""'");
3802   }
3803   arg1 = (ldb_dn *)(argp1);
3804   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3805   if (!SWIG_IsOK(res2)) {
3806     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___cmp__" "', argument " "2"" of type '" "ldb_dn *""'");
3807   }
3808   arg2 = (ldb_dn *)(argp2);
3809   result = (int)ldb_dn_compare(arg1,arg2);
3810   resultobj = SWIG_From_int((int)(result));
3811   return resultobj;
3812 fail:
3813   return NULL;
3814 }
3815
3816
3817 SWIGINTERN PyObject *_wrap_Dn_is_valid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3818   PyObject *resultobj = 0;
3819   ldb_dn *arg1 = (ldb_dn *) 0 ;
3820   void *argp1 = 0 ;
3821   int res1 = 0 ;
3822   PyObject *swig_obj[1] ;
3823   bool result;
3824
3825   if (!args) SWIG_fail;
3826   swig_obj[0] = args;
3827   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3828   if (!SWIG_IsOK(res1)) {
3829     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_valid" "', argument " "1"" of type '" "ldb_dn *""'");
3830   }
3831   arg1 = (ldb_dn *)(argp1);
3832   result = (bool)ldb_dn_is_valid(arg1);
3833   resultobj = SWIG_From_bool((bool)(result));
3834   return resultobj;
3835 fail:
3836   return NULL;
3837 }
3838
3839
3840 SWIGINTERN PyObject *_wrap_Dn_is_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3841   PyObject *resultobj = 0;
3842   ldb_dn *arg1 = (ldb_dn *) 0 ;
3843   void *argp1 = 0 ;
3844   int res1 = 0 ;
3845   PyObject *swig_obj[1] ;
3846   bool result;
3847
3848   if (!args) SWIG_fail;
3849   swig_obj[0] = args;
3850   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3851   if (!SWIG_IsOK(res1)) {
3852     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_special" "', argument " "1"" of type '" "ldb_dn *""'");
3853   }
3854   arg1 = (ldb_dn *)(argp1);
3855   result = (bool)ldb_dn_is_special(arg1);
3856   resultobj = SWIG_From_bool((bool)(result));
3857   return resultobj;
3858 fail:
3859   return NULL;
3860 }
3861
3862
3863 SWIGINTERN PyObject *_wrap_Dn_is_null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3864   PyObject *resultobj = 0;
3865   ldb_dn *arg1 = (ldb_dn *) 0 ;
3866   void *argp1 = 0 ;
3867   int res1 = 0 ;
3868   PyObject *swig_obj[1] ;
3869   bool result;
3870
3871   if (!args) SWIG_fail;
3872   swig_obj[0] = args;
3873   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3874   if (!SWIG_IsOK(res1)) {
3875     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_null" "', argument " "1"" of type '" "ldb_dn *""'");
3876   }
3877   arg1 = (ldb_dn *)(argp1);
3878   result = (bool)ldb_dn_is_null(arg1);
3879   resultobj = SWIG_From_bool((bool)(result));
3880   return resultobj;
3881 fail:
3882   return NULL;
3883 }
3884
3885
3886 SWIGINTERN PyObject *_wrap_Dn_check_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3887   PyObject *resultobj = 0;
3888   ldb_dn *arg1 = (ldb_dn *) 0 ;
3889   char *arg2 = (char *) 0 ;
3890   void *argp1 = 0 ;
3891   int res1 = 0 ;
3892   int res2 ;
3893   char *buf2 = 0 ;
3894   int alloc2 = 0 ;
3895   PyObject * obj0 = 0 ;
3896   PyObject * obj1 = 0 ;
3897   char *  kwnames[] = {
3898     (char *) "self",(char *) "name", NULL
3899   };
3900   bool result;
3901
3902   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_check_special",kwnames,&obj0,&obj1)) SWIG_fail;
3903   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3904   if (!SWIG_IsOK(res1)) {
3905     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_check_special" "', argument " "1"" of type '" "ldb_dn *""'");
3906   }
3907   arg1 = (ldb_dn *)(argp1);
3908   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3909   if (!SWIG_IsOK(res2)) {
3910     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_check_special" "', argument " "2"" of type '" "char const *""'");
3911   }
3912   arg2 = (char *)(buf2);
3913   result = (bool)ldb_dn_check_special(arg1,(char const *)arg2);
3914   resultobj = SWIG_From_bool((bool)(result));
3915   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3916   return resultobj;
3917 fail:
3918   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3919   return NULL;
3920 }
3921
3922
3923 SWIGINTERN PyObject *_wrap_Dn___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3924   PyObject *resultobj = 0;
3925   ldb_dn *arg1 = (ldb_dn *) 0 ;
3926   void *argp1 = 0 ;
3927   int res1 = 0 ;
3928   PyObject *swig_obj[1] ;
3929   int result;
3930
3931   if (!args) SWIG_fail;
3932   swig_obj[0] = args;
3933   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3934   if (!SWIG_IsOK(res1)) {
3935     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___len__" "', argument " "1"" of type '" "ldb_dn *""'");
3936   }
3937   arg1 = (ldb_dn *)(argp1);
3938   result = (int)ldb_dn_get_comp_num(arg1);
3939   resultobj = SWIG_From_int((int)(result));
3940   return resultobj;
3941 fail:
3942   return NULL;
3943 }
3944
3945
3946 SWIGINTERN PyObject *_wrap_Dn_add_child(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3947   PyObject *resultobj = 0;
3948   ldb_dn *arg1 = (ldb_dn *) 0 ;
3949   ldb_dn *arg2 = (ldb_dn *) 0 ;
3950   void *argp1 = 0 ;
3951   int res1 = 0 ;
3952   void *argp2 = 0 ;
3953   int res2 = 0 ;
3954   PyObject * obj0 = 0 ;
3955   PyObject * obj1 = 0 ;
3956   char *  kwnames[] = {
3957     (char *) "self",(char *) "child", NULL
3958   };
3959   bool result;
3960
3961   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_child",kwnames,&obj0,&obj1)) SWIG_fail;
3962   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3963   if (!SWIG_IsOK(res1)) {
3964     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_child" "', argument " "1"" of type '" "ldb_dn *""'");
3965   }
3966   arg1 = (ldb_dn *)(argp1);
3967   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3968   if (!SWIG_IsOK(res2)) {
3969     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_child" "', argument " "2"" of type '" "ldb_dn *""'");
3970   }
3971   arg2 = (ldb_dn *)(argp2);
3972   result = (bool)ldb_dn_add_child(arg1,arg2);
3973   resultobj = SWIG_From_bool((bool)(result));
3974   return resultobj;
3975 fail:
3976   return NULL;
3977 }
3978
3979
3980 SWIGINTERN PyObject *_wrap_Dn_add_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3981   PyObject *resultobj = 0;
3982   ldb_dn *arg1 = (ldb_dn *) 0 ;
3983   ldb_dn *arg2 = (ldb_dn *) 0 ;
3984   void *argp1 = 0 ;
3985   int res1 = 0 ;
3986   void *argp2 = 0 ;
3987   int res2 = 0 ;
3988   PyObject * obj0 = 0 ;
3989   PyObject * obj1 = 0 ;
3990   char *  kwnames[] = {
3991     (char *) "self",(char *) "base", NULL
3992   };
3993   bool result;
3994
3995   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_base",kwnames,&obj0,&obj1)) SWIG_fail;
3996   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3997   if (!SWIG_IsOK(res1)) {
3998     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_base" "', argument " "1"" of type '" "ldb_dn *""'");
3999   }
4000   arg1 = (ldb_dn *)(argp1);
4001   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
4002   if (!SWIG_IsOK(res2)) {
4003     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_base" "', argument " "2"" of type '" "ldb_dn *""'");
4004   }
4005   arg2 = (ldb_dn *)(argp2);
4006   result = (bool)ldb_dn_add_base(arg1,arg2);
4007   resultobj = SWIG_From_bool((bool)(result));
4008   return resultobj;
4009 fail:
4010   return NULL;
4011 }
4012
4013
4014 SWIGINTERN PyObject *_wrap_Dn_canonical_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4015   PyObject *resultobj = 0;
4016   ldb_dn *arg1 = (ldb_dn *) 0 ;
4017   void *argp1 = 0 ;
4018   int res1 = 0 ;
4019   PyObject *swig_obj[1] ;
4020   char *result = 0 ;
4021
4022   if (!args) SWIG_fail;
4023   swig_obj[0] = args;
4024   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4025   if (!SWIG_IsOK(res1)) {
4026     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_str" "', argument " "1"" of type '" "ldb_dn *""'");
4027   }
4028   arg1 = (ldb_dn *)(argp1);
4029   result = (char *)ldb_dn_canonical_str(arg1);
4030   resultobj = SWIG_FromCharPtr((const char *)result);
4031   return resultobj;
4032 fail:
4033   return NULL;
4034 }
4035
4036
4037 SWIGINTERN PyObject *_wrap_Dn_canonical_ex_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4038   PyObject *resultobj = 0;
4039   ldb_dn *arg1 = (ldb_dn *) 0 ;
4040   void *argp1 = 0 ;
4041   int res1 = 0 ;
4042   PyObject *swig_obj[1] ;
4043   char *result = 0 ;
4044
4045   if (!args) SWIG_fail;
4046   swig_obj[0] = args;
4047   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4048   if (!SWIG_IsOK(res1)) {
4049     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_ex_str" "', argument " "1"" of type '" "ldb_dn *""'");
4050   }
4051   arg1 = (ldb_dn *)(argp1);
4052   result = (char *)ldb_dn_canonical_ex_str(arg1);
4053   resultobj = SWIG_FromCharPtr((const char *)result);
4054   return resultobj;
4055 fail:
4056   return NULL;
4057 }
4058
4059
4060 SWIGINTERN PyObject *_wrap_Dn___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4061   PyObject *resultobj = 0;
4062   ldb_dn *arg1 = (ldb_dn *) 0 ;
4063   void *argp1 = 0 ;
4064   int res1 = 0 ;
4065   PyObject *swig_obj[1] ;
4066   char *result = 0 ;
4067
4068   if (!args) SWIG_fail;
4069   swig_obj[0] = args;
4070   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4071   if (!SWIG_IsOK(res1)) {
4072     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___repr__" "', argument " "1"" of type '" "ldb_dn *""'");
4073   }
4074   arg1 = (ldb_dn *)(argp1);
4075   result = (char *)ldb_dn___repr__(arg1);
4076   resultobj = SWIG_FromCharPtr((const char *)result);
4077   return resultobj;
4078 fail:
4079   return NULL;
4080 }
4081
4082
4083 SWIGINTERN PyObject *_wrap_Dn___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4084   PyObject *resultobj = 0;
4085   ldb_dn *arg1 = (ldb_dn *) 0 ;
4086   ldb_dn *arg2 = (ldb_dn *) 0 ;
4087   void *argp1 = 0 ;
4088   int res1 = 0 ;
4089   void *argp2 = 0 ;
4090   int res2 = 0 ;
4091   PyObject * obj0 = 0 ;
4092   PyObject * obj1 = 0 ;
4093   char *  kwnames[] = {
4094     (char *) "self",(char *) "other", NULL
4095   };
4096   ldb_dn *result = 0 ;
4097
4098   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4099   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4100   if (!SWIG_IsOK(res1)) {
4101     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___add__" "', argument " "1"" of type '" "ldb_dn *""'");
4102   }
4103   arg1 = (ldb_dn *)(argp1);
4104   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
4105   if (!SWIG_IsOK(res2)) {
4106     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___add__" "', argument " "2"" of type '" "ldb_dn *""'");
4107   }
4108   arg2 = (ldb_dn *)(argp2);
4109   result = (ldb_dn *)ldb_dn___add__(arg1,arg2);
4110   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4111   return resultobj;
4112 fail:
4113   return NULL;
4114 }
4115
4116
4117 SWIGINTERN PyObject *Dn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4118   PyObject *obj;
4119   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4120   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_dn, SWIG_NewClientData(obj));
4121   return SWIG_Py_Void();
4122 }
4123
4124 SWIGINTERN PyObject *Dn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4125   return SWIG_Python_InitShadowInstance(args);
4126 }
4127
4128 SWIGINTERN PyObject *_wrap_MessageElement___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4129   PyObject *resultobj = 0;
4130   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4131   ldb_message_element *arg2 = (ldb_message_element *) 0 ;
4132   void *argp1 = 0 ;
4133   int res1 = 0 ;
4134   void *argp2 = 0 ;
4135   int res2 = 0 ;
4136   PyObject * obj0 = 0 ;
4137   PyObject * obj1 = 0 ;
4138   char *  kwnames[] = {
4139     (char *) "self",(char *) "other", NULL
4140   };
4141   int result;
4142
4143   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MessageElement___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
4144   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4145   if (!SWIG_IsOK(res1)) {
4146     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___cmp__" "', argument " "1"" of type '" "ldb_message_element *""'");
4147   }
4148   arg1 = (ldb_message_element *)(argp1);
4149   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4150   if (!SWIG_IsOK(res2)) {
4151     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageElement___cmp__" "', argument " "2"" of type '" "ldb_message_element *""'");
4152   }
4153   arg2 = (ldb_message_element *)(argp2);
4154   result = (int)ldb_message_element___cmp__(arg1,arg2);
4155   resultobj = SWIG_From_int((int)(result));
4156   return resultobj;
4157 fail:
4158   return NULL;
4159 }
4160
4161
4162 SWIGINTERN PyObject *_wrap_MessageElement___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4163   PyObject *resultobj = 0;
4164   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4165   void *argp1 = 0 ;
4166   int res1 = 0 ;
4167   PyObject *swig_obj[1] ;
4168   PyObject *result = 0 ;
4169
4170   if (!args) SWIG_fail;
4171   swig_obj[0] = args;
4172   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4173   if (!SWIG_IsOK(res1)) {
4174     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___iter__" "', argument " "1"" of type '" "ldb_message_element *""'");
4175   }
4176   arg1 = (ldb_message_element *)(argp1);
4177   result = (PyObject *)ldb_message_element___iter__(arg1);
4178   resultobj = result;
4179   return resultobj;
4180 fail:
4181   return NULL;
4182 }
4183
4184
4185 SWIGINTERN PyObject *_wrap_MessageElement___set__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4186   PyObject *resultobj = 0;
4187   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4188   void *argp1 = 0 ;
4189   int res1 = 0 ;
4190   PyObject *swig_obj[1] ;
4191   PyObject *result = 0 ;
4192
4193   if (!args) SWIG_fail;
4194   swig_obj[0] = args;
4195   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4196   if (!SWIG_IsOK(res1)) {
4197     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___set__" "', argument " "1"" of type '" "ldb_message_element *""'");
4198   }
4199   arg1 = (ldb_message_element *)(argp1);
4200   result = (PyObject *)ldb_message_element___set__(arg1);
4201   resultobj = result;
4202   return resultobj;
4203 fail:
4204   return NULL;
4205 }
4206
4207
4208 SWIGINTERN PyObject *_wrap_new_MessageElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4209   PyObject *resultobj = 0;
4210   PyObject *arg1 = (PyObject *) 0 ;
4211   int arg2 = (int) 0 ;
4212   char *arg3 = (char *) NULL ;
4213   int val2 ;
4214   int ecode2 = 0 ;
4215   int res3 ;
4216   char *buf3 = 0 ;
4217   int alloc3 = 0 ;
4218   PyObject * obj0 = 0 ;
4219   PyObject * obj1 = 0 ;
4220   PyObject * obj2 = 0 ;
4221   char *  kwnames[] = {
4222     (char *) "set_obj",(char *) "flags",(char *) "name", NULL
4223   };
4224   ldb_message_element *result = 0 ;
4225
4226   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_MessageElement",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4227   arg1 = obj0;
4228   if (obj1) {
4229     ecode2 = SWIG_AsVal_int(obj1, &val2);
4230     if (!SWIG_IsOK(ecode2)) {
4231       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MessageElement" "', argument " "2"" of type '" "int""'");
4232     }
4233     arg2 = (int)(val2);
4234   }
4235   if (obj2) {
4236     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
4237     if (!SWIG_IsOK(res3)) {
4238       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MessageElement" "', argument " "3"" of type '" "char const *""'");
4239     }
4240     arg3 = (char *)(buf3);
4241   }
4242   result = (ldb_message_element *)new_ldb_message_element(arg1,arg2,(char const *)arg3);
4243   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message_element, SWIG_POINTER_NEW |  0 );
4244   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4245   return resultobj;
4246 fail:
4247   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4248   return NULL;
4249 }
4250
4251
4252 SWIGINTERN PyObject *_wrap_MessageElement___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4253   PyObject *resultobj = 0;
4254   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4255   void *argp1 = 0 ;
4256   int res1 = 0 ;
4257   PyObject *swig_obj[1] ;
4258   int result;
4259
4260   if (!args) SWIG_fail;
4261   swig_obj[0] = args;
4262   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4263   if (!SWIG_IsOK(res1)) {
4264     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___len__" "', argument " "1"" of type '" "ldb_message_element *""'");
4265   }
4266   arg1 = (ldb_message_element *)(argp1);
4267   result = (int)ldb_message_element___len__(arg1);
4268   resultobj = SWIG_From_int((int)(result));
4269   return resultobj;
4270 fail:
4271   return NULL;
4272 }
4273
4274
4275 SWIGINTERN PyObject *_wrap_MessageElement_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4276   PyObject *resultobj = 0;
4277   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4278   int arg2 ;
4279   void *argp1 = 0 ;
4280   int res1 = 0 ;
4281   int val2 ;
4282   int ecode2 = 0 ;
4283   PyObject * obj0 = 0 ;
4284   PyObject * obj1 = 0 ;
4285   char *  kwnames[] = {
4286     (char *) "self",(char *) "i", NULL
4287   };
4288   PyObject *result = 0 ;
4289
4290   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MessageElement_get",kwnames,&obj0,&obj1)) SWIG_fail;
4291   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4292   if (!SWIG_IsOK(res1)) {
4293     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement_get" "', argument " "1"" of type '" "ldb_message_element *""'");
4294   }
4295   arg1 = (ldb_message_element *)(argp1);
4296   ecode2 = SWIG_AsVal_int(obj1, &val2);
4297   if (!SWIG_IsOK(ecode2)) {
4298     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageElement_get" "', argument " "2"" of type '" "int""'");
4299   }
4300   arg2 = (int)(val2);
4301   result = (PyObject *)ldb_message_element_get(arg1,arg2);
4302   resultobj = result;
4303   return resultobj;
4304 fail:
4305   return NULL;
4306 }
4307
4308
4309 SWIGINTERN PyObject *_wrap_delete_MessageElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4310   PyObject *resultobj = 0;
4311   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
4312   void *argp1 = 0 ;
4313   int res1 = 0 ;
4314   PyObject *swig_obj[1] ;
4315
4316   if (!args) SWIG_fail;
4317   swig_obj[0] = args;
4318   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, SWIG_POINTER_DISOWN |  0 );
4319   if (!SWIG_IsOK(res1)) {
4320     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageElement" "', argument " "1"" of type '" "ldb_message_element *""'");
4321   }
4322   arg1 = (ldb_message_element *)(argp1);
4323   delete_ldb_message_element(arg1);
4324   resultobj = SWIG_Py_Void();
4325   return resultobj;
4326 fail:
4327   return NULL;
4328 }
4329
4330
4331 SWIGINTERN PyObject *MessageElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4332   PyObject *obj;
4333   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4334   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message_element, SWIG_NewClientData(obj));
4335   return SWIG_Py_Void();
4336 }
4337
4338 SWIGINTERN PyObject *MessageElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4339   return SWIG_Python_InitShadowInstance(args);
4340 }
4341
4342 SWIGINTERN PyObject *_wrap_ldb_msg_list_elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4343   PyObject *resultobj = 0;
4344   ldb_msg *arg1 = (ldb_msg *) 0 ;
4345   void *argp1 = 0 ;
4346   int res1 = 0 ;
4347   PyObject * obj0 = 0 ;
4348   char *  kwnames[] = {
4349     (char *) "msg", NULL
4350   };
4351   PyObject *result = 0 ;
4352
4353   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_msg_list_elements",kwnames,&obj0)) SWIG_fail;
4354   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4355   if (!SWIG_IsOK(res1)) {
4356     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_list_elements" "', argument " "1"" of type '" "ldb_msg *""'");
4357   }
4358   arg1 = (ldb_msg *)(argp1);
4359   if (arg1 == NULL)
4360   SWIG_exception(SWIG_ValueError,
4361     "Message can not be None");
4362   result = (PyObject *)ldb_msg_list_elements(arg1);
4363   resultobj = result;
4364   return resultobj;
4365 fail:
4366   return NULL;
4367 }
4368
4369
4370 SWIGINTERN PyObject *_wrap_Message_dn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4371   PyObject *resultobj = 0;
4372   ldb_msg *arg1 = (ldb_msg *) 0 ;
4373   ldb_dn *arg2 = (ldb_dn *) 0 ;
4374   void *argp1 = 0 ;
4375   int res1 = 0 ;
4376   void *argp2 = 0 ;
4377   int res2 = 0 ;
4378   PyObject *swig_obj[2] ;
4379
4380   if (!SWIG_Python_UnpackTuple(args,"Message_dn_set",2,2,swig_obj)) SWIG_fail;
4381   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4382   if (!SWIG_IsOK(res1)) {
4383     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_set" "', argument " "1"" of type '" "ldb_msg *""'");
4384   }
4385   arg1 = (ldb_msg *)(argp1);
4386   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
4387   if (!SWIG_IsOK(res2)) {
4388     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_dn_set" "', argument " "2"" of type '" "ldb_dn *""'");
4389   }
4390   arg2 = (ldb_dn *)(argp2);
4391   if (arg1 == NULL)
4392   SWIG_exception(SWIG_ValueError,
4393     "Message can not be None");
4394   if (arg1) (arg1)->dn = arg2;
4395   resultobj = SWIG_Py_Void();
4396   return resultobj;
4397 fail:
4398   return NULL;
4399 }
4400
4401
4402 SWIGINTERN PyObject *_wrap_Message_dn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4403   PyObject *resultobj = 0;
4404   ldb_msg *arg1 = (ldb_msg *) 0 ;
4405   void *argp1 = 0 ;
4406   int res1 = 0 ;
4407   PyObject *swig_obj[1] ;
4408   ldb_dn *result = 0 ;
4409
4410   if (!args) SWIG_fail;
4411   swig_obj[0] = args;
4412   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4413   if (!SWIG_IsOK(res1)) {
4414     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_get" "', argument " "1"" of type '" "ldb_msg *""'");
4415   }
4416   arg1 = (ldb_msg *)(argp1);
4417   if (arg1 == NULL)
4418   SWIG_exception(SWIG_ValueError,
4419     "Message can not be None");
4420   result = (ldb_dn *) ((arg1)->dn);
4421   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4422   return resultobj;
4423 fail:
4424   return NULL;
4425 }
4426
4427
4428 SWIGINTERN PyObject *_wrap_new_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4429   PyObject *resultobj = 0;
4430   ldb_dn *arg1 = (ldb_dn *) NULL ;
4431   void *argp1 = 0 ;
4432   int res1 = 0 ;
4433   PyObject * obj0 = 0 ;
4434   char *  kwnames[] = {
4435     (char *) "dn", NULL
4436   };
4437   ldb_msg *result = 0 ;
4438
4439   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Message",kwnames,&obj0)) SWIG_fail;
4440   if (obj0) {
4441     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4442     if (!SWIG_IsOK(res1)) {
4443       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "ldb_dn *""'");
4444     }
4445     arg1 = (ldb_dn *)(argp1);
4446   }
4447   result = (ldb_msg *)new_ldb_msg(arg1);
4448   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message, SWIG_POINTER_NEW |  0 );
4449   return resultobj;
4450 fail:
4451   return NULL;
4452 }
4453
4454
4455 SWIGINTERN PyObject *_wrap_delete_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4456   PyObject *resultobj = 0;
4457   ldb_msg *arg1 = (ldb_msg *) 0 ;
4458   void *argp1 = 0 ;
4459   int res1 = 0 ;
4460   PyObject *swig_obj[1] ;
4461
4462   if (!args) SWIG_fail;
4463   swig_obj[0] = args;
4464   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, SWIG_POINTER_DISOWN |  0 );
4465   if (!SWIG_IsOK(res1)) {
4466     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Message" "', argument " "1"" of type '" "ldb_msg *""'");
4467   }
4468   arg1 = (ldb_msg *)(argp1);
4469   if (arg1 == NULL)
4470   SWIG_exception(SWIG_ValueError,
4471     "Message can not be None");
4472   delete_ldb_msg(arg1);
4473   resultobj = SWIG_Py_Void();
4474   return resultobj;
4475 fail:
4476   return NULL;
4477 }
4478
4479
4480 SWIGINTERN PyObject *_wrap_Message_find_element(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4481   PyObject *resultobj = 0;
4482   ldb_msg *arg1 = (ldb_msg *) 0 ;
4483   char *arg2 = (char *) 0 ;
4484   void *argp1 = 0 ;
4485   int res1 = 0 ;
4486   int res2 ;
4487   char *buf2 = 0 ;
4488   int alloc2 = 0 ;
4489   PyObject * obj0 = 0 ;
4490   PyObject * obj1 = 0 ;
4491   char *  kwnames[] = {
4492     (char *) "self",(char *) "name", NULL
4493   };
4494   ldb_message_element *result = 0 ;
4495
4496   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message_find_element",kwnames,&obj0,&obj1)) SWIG_fail;
4497   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4498   if (!SWIG_IsOK(res1)) {
4499     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_find_element" "', argument " "1"" of type '" "ldb_msg *""'");
4500   }
4501   arg1 = (ldb_msg *)(argp1);
4502   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4503   if (!SWIG_IsOK(res2)) {
4504     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_find_element" "', argument " "2"" of type '" "char const *""'");
4505   }
4506   arg2 = (char *)(buf2);
4507   if (arg1 == NULL)
4508   SWIG_exception(SWIG_ValueError,
4509     "Message can not be None");
4510   result = (ldb_message_element *)ldb_msg_find_element(arg1,(char const *)arg2);
4511   {
4512     if (result == NULL)
4513     PyErr_SetString(PyExc_KeyError, "no such element");
4514     else
4515     resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_ldb_message_element, 0);
4516   }
4517   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4518   return resultobj;
4519 fail:
4520   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4521   return NULL;
4522 }
4523
4524
4525 SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4526   PyObject *resultobj = 0;
4527   ldb_msg *arg1 = (ldb_msg *) 0 ;
4528   char *arg2 = (char *) 0 ;
4529   ldb_message_element *arg3 = (ldb_message_element *) 0 ;
4530   void *argp1 = 0 ;
4531   int res1 = 0 ;
4532   int res2 ;
4533   char *buf2 = 0 ;
4534   int alloc2 = 0 ;
4535   void *argp3 = 0 ;
4536   int res3 = 0 ;
4537
4538   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
4539   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4540   if (!SWIG_IsOK(res1)) {
4541     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4542   }
4543   arg1 = (ldb_msg *)(argp1);
4544   res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
4545   if (!SWIG_IsOK(res2)) {
4546     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
4547   }
4548   arg2 = (char *)(buf2);
4549   res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4550   if (!SWIG_IsOK(res3)) {
4551     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message___setitem__" "', argument " "3"" of type '" "ldb_message_element *""'");
4552   }
4553   arg3 = (ldb_message_element *)(argp3);
4554   if (arg1 == NULL)
4555   SWIG_exception(SWIG_ValueError,
4556     "Message can not be None");
4557   ldb_msg___setitem____SWIG_0(arg1,(char const *)arg2,arg3);
4558   resultobj = SWIG_Py_Void();
4559   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4560   return resultobj;
4561 fail:
4562   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4563   return NULL;
4564 }
4565
4566
4567 SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4568   PyObject *resultobj = 0;
4569   ldb_msg *arg1 = (ldb_msg *) 0 ;
4570   char *arg2 = (char *) 0 ;
4571   PyObject *arg3 = (PyObject *) 0 ;
4572   void *argp1 = 0 ;
4573   int res1 = 0 ;
4574   int res2 ;
4575   char *buf2 = 0 ;
4576   int alloc2 = 0 ;
4577
4578   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
4579   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4580   if (!SWIG_IsOK(res1)) {
4581     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4582   }
4583   arg1 = (ldb_msg *)(argp1);
4584   res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
4585   if (!SWIG_IsOK(res2)) {
4586     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
4587   }
4588   arg2 = (char *)(buf2);
4589   arg3 = swig_obj[2];
4590   if (arg1 == NULL)
4591   SWIG_exception(SWIG_ValueError,
4592     "Message can not be None");
4593   ldb_msg___setitem____SWIG_1(arg1,(char const *)arg2,arg3);
4594   resultobj = SWIG_Py_Void();
4595   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4596   return resultobj;
4597 fail:
4598   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4599   return NULL;
4600 }
4601
4602
4603 SWIGINTERN PyObject *_wrap_Message___setitem__(PyObject *self, PyObject *args) {
4604   int argc;
4605   PyObject *argv[4];
4606
4607   if (!(argc = SWIG_Python_UnpackTuple(args,"Message___setitem__",0,3,argv))) SWIG_fail;
4608   --argc;
4609   if (argc == 3) {
4610     int _v = 0;
4611     {
4612       void *vptr = 0;
4613       int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ldb_message_element, 0);
4614       _v = SWIG_CheckState(res);
4615     }
4616     if (!_v) goto check_1;
4617     return _wrap_Message___setitem____SWIG_0(self, argc, argv);
4618   }
4619 check_1:
4620
4621   if (argc == 3) {
4622     return _wrap_Message___setitem____SWIG_1(self, argc, argv);
4623   }
4624
4625 fail:
4626   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message___setitem__'.\n"
4627     "  Possible C/C++ prototypes are:\n"
4628     "    __setitem__(ldb_msg *,char const *,ldb_message_element *)\n"
4629     "    __setitem__(ldb_msg *,char const *,PyObject *)\n");
4630   return NULL;
4631 }
4632
4633
4634 SWIGINTERN PyObject *_wrap_Message___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4635   PyObject *resultobj = 0;
4636   ldb_msg *arg1 = (ldb_msg *) 0 ;
4637   void *argp1 = 0 ;
4638   int res1 = 0 ;
4639   PyObject *swig_obj[1] ;
4640   unsigned int result;
4641
4642   if (!args) SWIG_fail;
4643   swig_obj[0] = args;
4644   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4645   if (!SWIG_IsOK(res1)) {
4646     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___len__" "', argument " "1"" of type '" "ldb_msg *""'");
4647   }
4648   arg1 = (ldb_msg *)(argp1);
4649   if (arg1 == NULL)
4650   SWIG_exception(SWIG_ValueError,
4651     "Message can not be None");
4652   result = (unsigned int)ldb_msg___len__(arg1);
4653   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4654   return resultobj;
4655 fail:
4656   return NULL;
4657 }
4658
4659
4660 SWIGINTERN PyObject *_wrap_Message_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4661   PyObject *resultobj = 0;
4662   ldb_msg *arg1 = (ldb_msg *) 0 ;
4663   void *argp1 = 0 ;
4664   int res1 = 0 ;
4665   PyObject *swig_obj[1] ;
4666   PyObject *result = 0 ;
4667
4668   if (!args) SWIG_fail;
4669   swig_obj[0] = args;
4670   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4671   if (!SWIG_IsOK(res1)) {
4672     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_keys" "', argument " "1"" of type '" "ldb_msg *""'");
4673   }
4674   arg1 = (ldb_msg *)(argp1);
4675   if (arg1 == NULL)
4676   SWIG_exception(SWIG_ValueError,
4677     "Message can not be None");
4678   result = (PyObject *)ldb_msg_keys(arg1);
4679   resultobj = result;
4680   return resultobj;
4681 fail:
4682   return NULL;
4683 }
4684
4685
4686 SWIGINTERN PyObject *_wrap_Message___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4687   PyObject *resultobj = 0;
4688   ldb_msg *arg1 = (ldb_msg *) 0 ;
4689   void *argp1 = 0 ;
4690   int res1 = 0 ;
4691   PyObject *swig_obj[1] ;
4692   PyObject *result = 0 ;
4693
4694   if (!args) SWIG_fail;
4695   swig_obj[0] = args;
4696   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4697   if (!SWIG_IsOK(res1)) {
4698     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___iter__" "', argument " "1"" of type '" "ldb_msg *""'");
4699   }
4700   arg1 = (ldb_msg *)(argp1);
4701   if (arg1 == NULL)
4702   SWIG_exception(SWIG_ValueError,
4703     "Message can not be None");
4704   result = (PyObject *)ldb_msg___iter__(arg1);
4705   resultobj = result;
4706   return resultobj;
4707 fail:
4708   return NULL;
4709 }
4710
4711
4712 SWIGINTERN PyObject *_wrap_Message___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4713   PyObject *resultobj = 0;
4714   ldb_msg *arg1 = (ldb_msg *) 0 ;
4715   char *arg2 = (char *) 0 ;
4716   void *argp1 = 0 ;
4717   int res1 = 0 ;
4718   int res2 ;
4719   char *buf2 = 0 ;
4720   int alloc2 = 0 ;
4721   PyObject * obj0 = 0 ;
4722   PyObject * obj1 = 0 ;
4723   char *  kwnames[] = {
4724     (char *) "self",(char *) "name", NULL
4725   };
4726
4727   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message___delitem__",kwnames,&obj0,&obj1)) SWIG_fail;
4728   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4729   if (!SWIG_IsOK(res1)) {
4730     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___delitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4731   }
4732   arg1 = (ldb_msg *)(argp1);
4733   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4734   if (!SWIG_IsOK(res2)) {
4735     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___delitem__" "', argument " "2"" of type '" "char const *""'");
4736   }
4737   arg2 = (char *)(buf2);
4738   if (arg1 == NULL)
4739   SWIG_exception(SWIG_ValueError,
4740     "Message can not be None");
4741   ldb_msg_remove_attr(arg1,(char const *)arg2);
4742   resultobj = SWIG_Py_Void();
4743   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4744   return resultobj;
4745 fail:
4746   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4747   return NULL;
4748 }
4749
4750
4751 SWIGINTERN PyObject *Message_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4752   PyObject *obj;
4753   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4754   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message, SWIG_NewClientData(obj));
4755   return SWIG_Py_Void();
4756 }
4757
4758 SWIGINTERN PyObject *Message_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4759   return SWIG_Python_InitShadowInstance(args);
4760 }
4761
4762 SWIGINTERN PyObject *_wrap_ldb_ldif_to_pyobject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4763   PyObject *resultobj = 0;
4764   ldb_ldif *arg1 = (ldb_ldif *) 0 ;
4765   void *argp1 = 0 ;
4766   int res1 = 0 ;
4767   PyObject * obj0 = 0 ;
4768   char *  kwnames[] = {
4769     (char *) "ldif", NULL
4770   };
4771   PyObject *result = 0 ;
4772
4773   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_ldif_to_pyobject",kwnames,&obj0)) SWIG_fail;
4774   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_ldif, 0 |  0 );
4775   if (!SWIG_IsOK(res1)) {
4776     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_ldif_to_pyobject" "', argument " "1"" of type '" "ldb_ldif *""'");
4777   }
4778   arg1 = (ldb_ldif *)(argp1);
4779   result = (PyObject *)ldb_ldif_to_pyobject(arg1);
4780   resultobj = result;
4781   return resultobj;
4782 fail:
4783   return NULL;
4784 }
4785
4786
4787 SWIGINTERN PyObject *_wrap_Ldb_firstmodule_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4788   PyObject *resultobj = 0;
4789   ldb *arg1 = (ldb *) 0 ;
4790   struct ldb_module *arg2 = (struct ldb_module *) 0 ;
4791   void *argp1 = 0 ;
4792   int res1 = 0 ;
4793   void *argp2 = 0 ;
4794   int res2 = 0 ;
4795   PyObject *swig_obj[2] ;
4796
4797   if (!SWIG_Python_UnpackTuple(args,"Ldb_firstmodule_set",2,2,swig_obj)) SWIG_fail;
4798   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4799   if (!SWIG_IsOK(res1)) {
4800     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_firstmodule_set" "', argument " "1"" of type '" "ldb *""'");
4801   }
4802   arg1 = (ldb *)(argp1);
4803   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
4804   if (!SWIG_IsOK(res2)) {
4805     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_firstmodule_set" "', argument " "2"" of type '" "struct ldb_module *""'");
4806   }
4807   arg2 = (struct ldb_module *)(argp2);
4808   if (arg1 == NULL)
4809   SWIG_exception(SWIG_ValueError,
4810     "ldb context must be non-NULL");
4811   if (arg1) (arg1)->modules = arg2;
4812   resultobj = SWIG_Py_Void();
4813   return resultobj;
4814 fail:
4815   return NULL;
4816 }
4817
4818
4819 SWIGINTERN PyObject *_wrap_Ldb_firstmodule_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4820   PyObject *resultobj = 0;
4821   ldb *arg1 = (ldb *) 0 ;
4822   void *argp1 = 0 ;
4823   int res1 = 0 ;
4824   PyObject *swig_obj[1] ;
4825   struct ldb_module *result = 0 ;
4826
4827   if (!args) SWIG_fail;
4828   swig_obj[0] = args;
4829   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4830   if (!SWIG_IsOK(res1)) {
4831     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_firstmodule_get" "', argument " "1"" of type '" "ldb *""'");
4832   }
4833   arg1 = (ldb *)(argp1);
4834   if (arg1 == NULL)
4835   SWIG_exception(SWIG_ValueError,
4836     "ldb context must be non-NULL");
4837   result = (struct ldb_module *) ((arg1)->modules);
4838   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 |  0 );
4839   return resultobj;
4840 fail:
4841   return NULL;
4842 }
4843
4844
4845 SWIGINTERN PyObject *_wrap_new_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4846   PyObject *resultobj = 0;
4847   ldb *result = 0 ;
4848
4849   if (!SWIG_Python_UnpackTuple(args,"new_Ldb",0,0,0)) SWIG_fail;
4850   result = (ldb *)new_ldb();
4851   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_context, SWIG_POINTER_NEW |  0 );
4852   return resultobj;
4853 fail:
4854   return NULL;
4855 }
4856
4857
4858 SWIGINTERN PyObject *_wrap_Ldb_connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4859   PyObject *resultobj = 0;
4860   ldb *arg1 = (ldb *) 0 ;
4861   char *arg2 = (char *) 0 ;
4862   unsigned int arg3 = (unsigned int) 0 ;
4863   char **arg4 = (char **) (char **)NULL ;
4864   void *argp1 = 0 ;
4865   int res1 = 0 ;
4866   int res2 ;
4867   char *buf2 = 0 ;
4868   int alloc2 = 0 ;
4869   unsigned int val3 ;
4870   int ecode3 = 0 ;
4871   void *argp4 = 0 ;
4872   int res4 = 0 ;
4873   PyObject * obj0 = 0 ;
4874   PyObject * obj1 = 0 ;
4875   PyObject * obj2 = 0 ;
4876   PyObject * obj3 = 0 ;
4877   char *  kwnames[] = {
4878     (char *) "self",(char *) "url",(char *) "flags",(char *) "options", NULL
4879   };
4880   ldb_error result;
4881
4882   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Ldb_connect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4883   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4884   if (!SWIG_IsOK(res1)) {
4885     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_connect" "', argument " "1"" of type '" "ldb *""'");
4886   }
4887   arg1 = (ldb *)(argp1);
4888   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4889   if (!SWIG_IsOK(res2)) {
4890     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_connect" "', argument " "2"" of type '" "char const *""'");
4891   }
4892   arg2 = (char *)(buf2);
4893   if (obj2) {
4894     ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
4895     if (!SWIG_IsOK(ecode3)) {
4896       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_connect" "', argument " "3"" of type '" "unsigned int""'");
4897     }
4898     arg3 = (unsigned int)(val3);
4899   }
4900   if (obj3) {
4901     res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_char, 0 |  0 );
4902     if (!SWIG_IsOK(res4)) {
4903       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_connect" "', argument " "4"" of type '" "char const *[]""'");
4904     }
4905     arg4 = (char **)(argp4);
4906   }
4907   if (arg1 == NULL)
4908   SWIG_exception(SWIG_ValueError,
4909     "ldb context must be non-NULL");
4910   result = ldb_connect(arg1,(char const *)arg2,arg3,(char const *(*))arg4);
4911   if (result != 0) {
4912     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4913     SWIG_fail;
4914   }
4915   resultobj = Py_None;
4916   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4917   return resultobj;
4918 fail:
4919   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4920   return NULL;
4921 }
4922
4923
4924 SWIGINTERN PyObject *_wrap_delete_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4925   PyObject *resultobj = 0;
4926   ldb *arg1 = (ldb *) 0 ;
4927   void *argp1 = 0 ;
4928   int res1 = 0 ;
4929   PyObject *swig_obj[1] ;
4930
4931   if (!args) SWIG_fail;
4932   swig_obj[0] = args;
4933   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, SWIG_POINTER_DISOWN |  0 );
4934   if (!SWIG_IsOK(res1)) {
4935     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ldb" "', argument " "1"" of type '" "ldb *""'");
4936   }
4937   arg1 = (ldb *)(argp1);
4938   if (arg1 == NULL)
4939   SWIG_exception(SWIG_ValueError,
4940     "ldb context must be non-NULL");
4941   delete_ldb(arg1);
4942   resultobj = SWIG_Py_Void();
4943   return resultobj;
4944 fail:
4945   return NULL;
4946 }
4947
4948
4949 SWIGINTERN PyObject *_wrap_Ldb_search_ex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4950   PyObject *resultobj = 0;
4951   ldb *arg1 = (ldb *) 0 ;
4952   TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
4953   ldb_dn *arg3 = (ldb_dn *) NULL ;
4954   enum ldb_scope arg4 = (enum ldb_scope) LDB_SCOPE_DEFAULT ;
4955   char *arg5 = (char *) NULL ;
4956   char **arg6 = (char **) NULL ;
4957   struct ldb_control **arg7 = (struct ldb_control **) NULL ;
4958   struct ldb_result **arg8 = (struct ldb_result **) 0 ;
4959   void *argp1 = 0 ;
4960   int res1 = 0 ;
4961   int val4 ;
4962   int ecode4 = 0 ;
4963   int res5 ;
4964   char *buf5 = 0 ;
4965   int alloc5 = 0 ;
4966   void *argp7 = 0 ;
4967   int res7 = 0 ;
4968   struct ldb_result *temp_ldb_result8 ;
4969   int i8 ;
4970   PyObject * obj0 = 0 ;
4971   PyObject * obj1 = 0 ;
4972   PyObject * obj2 = 0 ;
4973   PyObject * obj3 = 0 ;
4974   PyObject * obj4 = 0 ;
4975   PyObject * obj5 = 0 ;
4976   char *  kwnames[] = {
4977     (char *) "self",(char *) "base",(char *) "scope",(char *) "expression",(char *) "attrs",(char *) "controls", NULL
4978   };
4979   ldb_error result;
4980
4981   arg2 = NULL;
4982   arg8 = &temp_ldb_result8;
4983   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:Ldb_search_ex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4984   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4985   if (!SWIG_IsOK(res1)) {
4986     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_search_ex" "', argument " "1"" of type '" "ldb *""'");
4987   }
4988   arg1 = (ldb *)(argp1);
4989   if (obj1) {
4990     if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg3) != 0) {
4991       SWIG_fail;
4992     }
4993   }
4994   if (obj2) {
4995     ecode4 = SWIG_AsVal_int(obj2, &val4);
4996     if (!SWIG_IsOK(ecode4)) {
4997       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Ldb_search_ex" "', argument " "4"" of type '" "enum ldb_scope""'");
4998     }
4999     arg4 = (enum ldb_scope)(val4);
5000   }
5001   if (obj3) {
5002     res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
5003     if (!SWIG_IsOK(res5)) {
5004       SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Ldb_search_ex" "', argument " "5"" of type '" "char const *""'");
5005     }
5006     arg5 = (char *)(buf5);
5007   }
5008   if (obj4) {
5009     if (obj4 == Py_None) {
5010       arg6 = NULL;
5011     } else if (PySequence_Check(obj4)) {
5012       int i;
5013       arg6 = talloc_array(NULL, char *, PySequence_Size(obj4)+1);
5014       for(i = 0; i < PySequence_Size(obj4); i++)
5015       arg6[i] = PyString_AsString(PySequence_GetItem(obj4, i));
5016       arg6[i] = NULL;
5017     } else {
5018       SWIG_exception(SWIG_TypeError, "expected sequence");
5019     }
5020   }
5021   if (obj5) {
5022     res7 = SWIG_ConvertPtr(obj5, &argp7,SWIGTYPE_p_p_ldb_control, 0 |  0 );
5023     if (!SWIG_IsOK(res7)) {
5024       SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Ldb_search_ex" "', argument " "7"" of type '" "struct ldb_control **""'");
5025     }
5026     arg7 = (struct ldb_control **)(argp7);
5027   }
5028   if (arg1 == NULL)
5029   SWIG_exception(SWIG_ValueError,
5030     "ldb context must be non-NULL");
5031   result = ldb_search_ex(arg1,arg2,arg3,arg4,(char const *)arg5,(char const *const *)arg6,arg7,arg8);
5032   if (result != 0) {
5033     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5034     SWIG_fail;
5035   }
5036   resultobj = Py_None;
5037   if (arg8 == NULL) {
5038     resultobj = Py_None;
5039   } else {
5040     resultobj = PyList_New((*arg8)->count);
5041     for (i8 = 0; i8 < (*arg8)->count; i8++) {
5042       PyList_SetItem(resultobj, i8,
5043         SWIG_NewPointerObj((*arg8)->msgs[i8], SWIGTYPE_p_ldb_message, 0)
5044         );
5045     }
5046   }
5047   talloc_free(arg3);
5048   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5049   talloc_free(arg6);
5050   return resultobj;
5051 fail:
5052   talloc_free(arg3);
5053   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
5054   talloc_free(arg6);
5055   return NULL;
5056 }
5057
5058
5059 SWIGINTERN PyObject *_wrap_Ldb_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5060   PyObject *resultobj = 0;
5061   ldb *arg1 = (ldb *) 0 ;
5062   ldb_dn *arg2 = (ldb_dn *) 0 ;
5063   void *argp1 = 0 ;
5064   int res1 = 0 ;
5065   PyObject * obj0 = 0 ;
5066   PyObject * obj1 = 0 ;
5067   char *  kwnames[] = {
5068     (char *) "self",(char *) "dn", NULL
5069   };
5070   ldb_error result;
5071
5072   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_delete",kwnames,&obj0,&obj1)) SWIG_fail;
5073   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5074   if (!SWIG_IsOK(res1)) {
5075     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_delete" "', argument " "1"" of type '" "ldb *""'");
5076   }
5077   arg1 = (ldb *)(argp1);
5078   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
5079     SWIG_fail;
5080   }
5081   if (arg1 == NULL)
5082   SWIG_exception(SWIG_ValueError,
5083     "ldb context must be non-NULL");
5084   result = ldb_delete(arg1,arg2);
5085   if (result != 0) {
5086     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5087     SWIG_fail;
5088   }
5089   resultobj = Py_None;
5090   talloc_free(arg2);
5091   return resultobj;
5092 fail:
5093   talloc_free(arg2);
5094   return NULL;
5095 }
5096
5097
5098 SWIGINTERN PyObject *_wrap_Ldb_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5099   PyObject *resultobj = 0;
5100   ldb *arg1 = (ldb *) 0 ;
5101   ldb_dn *arg2 = (ldb_dn *) 0 ;
5102   ldb_dn *arg3 = (ldb_dn *) 0 ;
5103   void *argp1 = 0 ;
5104   int res1 = 0 ;
5105   PyObject * obj0 = 0 ;
5106   PyObject * obj1 = 0 ;
5107   PyObject * obj2 = 0 ;
5108   char *  kwnames[] = {
5109     (char *) "self",(char *) "olddn",(char *) "newdn", NULL
5110   };
5111   ldb_error result;
5112
5113   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_rename",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5114   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5115   if (!SWIG_IsOK(res1)) {
5116     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_rename" "', argument " "1"" of type '" "ldb *""'");
5117   }
5118   arg1 = (ldb *)(argp1);
5119   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
5120     SWIG_fail;
5121   }
5122   if (ldb_dn_from_pyobject(NULL, obj2, arg1, &arg3) != 0) {
5123     SWIG_fail;
5124   }
5125   if (arg1 == NULL)
5126   SWIG_exception(SWIG_ValueError,
5127     "ldb context must be non-NULL");
5128   result = ldb_rename(arg1,arg2,arg3);
5129   if (result != 0) {
5130     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5131     SWIG_fail;
5132   }
5133   resultobj = Py_None;
5134   talloc_free(arg2);
5135   talloc_free(arg3);
5136   return resultobj;
5137 fail:
5138   talloc_free(arg2);
5139   talloc_free(arg3);
5140   return NULL;
5141 }
5142
5143
5144 SWIGINTERN PyObject *_wrap_Ldb_parse_control_strings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5145   PyObject *resultobj = 0;
5146   ldb *arg1 = (ldb *) 0 ;
5147   TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
5148   char **arg3 = (char **) 0 ;
5149   void *argp1 = 0 ;
5150   int res1 = 0 ;
5151   PyObject * obj0 = 0 ;
5152   PyObject * obj1 = 0 ;
5153   char *  kwnames[] = {
5154     (char *) "self",(char *) "control_strings", NULL
5155   };
5156   struct ldb_control **result = 0 ;
5157
5158   arg2 = NULL;
5159   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_control_strings",kwnames,&obj0,&obj1)) SWIG_fail;
5160   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5161   if (!SWIG_IsOK(res1)) {
5162     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_control_strings" "', argument " "1"" of type '" "ldb *""'");
5163   }
5164   arg1 = (ldb *)(argp1);
5165   if (obj1 == Py_None) {
5166     arg3 = NULL;
5167   } else if (PySequence_Check(obj1)) {
5168     int i;
5169     arg3 = talloc_array(NULL, char *, PySequence_Size(obj1)+1);
5170     for(i = 0; i < PySequence_Size(obj1); i++)
5171     arg3[i] = PyString_AsString(PySequence_GetItem(obj1, i));
5172     arg3[i] = NULL;
5173   } else {
5174     SWIG_exception(SWIG_TypeError, "expected sequence");
5175   }
5176   if (arg1 == NULL)
5177   SWIG_exception(SWIG_ValueError,
5178     "ldb context must be non-NULL");
5179   result = (struct ldb_control **)ldb_parse_control_strings(arg1,arg2,(char const *const *)arg3);
5180   if (result == NULL) {
5181     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(s)", ldb_errstring(arg1)));
5182     SWIG_fail;
5183   }
5184   resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_p_ldb_control, 0);
5185   talloc_free(arg3);
5186   return resultobj;
5187 fail:
5188   talloc_free(arg3);
5189   return NULL;
5190 }
5191
5192
5193 SWIGINTERN PyObject *_wrap_Ldb_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5194   PyObject *resultobj = 0;
5195   ldb *arg1 = (ldb *) 0 ;
5196   ldb_msg *arg2 = (ldb_msg *) 0 ;
5197   void *argp1 = 0 ;
5198   int res1 = 0 ;
5199   PyObject * obj0 = 0 ;
5200   PyObject * obj1 = 0 ;
5201   char *  kwnames[] = {
5202     (char *) "self",(char *) "add_msg", NULL
5203   };
5204   ldb_error result;
5205
5206   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_add",kwnames,&obj0,&obj1)) SWIG_fail;
5207   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5208   if (!SWIG_IsOK(res1)) {
5209     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_add" "', argument " "1"" of type '" "ldb *""'");
5210   }
5211   arg1 = (ldb *)(argp1);
5212   {
5213     Py_ssize_t dict_pos, msg_pos;
5214     ldb_message_element *msgel;
5215     PyObject *key, *value;
5216
5217     if (PyDict_Check(obj1)) {
5218       PyObject *dn_value = PyDict_GetItemString(obj1, "dn");
5219       arg2 = ldb_msg_new(NULL);
5220       arg2->elements = talloc_zero_array(arg2, struct ldb_message_element, PyDict_Size(obj1));
5221       msg_pos = dict_pos = 0;
5222       if (dn_value) {
5223         /* using argp1 (magic SWIG value) here is a hack */
5224         if (ldb_dn_from_pyobject(arg2, dn_value, argp1, &arg2->dn) != 0) {
5225           SWIG_exception(SWIG_TypeError, "unable to import dn object");
5226         }
5227         if (arg2->dn == NULL) {
5228           SWIG_exception(SWIG_TypeError, "dn set but not found");
5229         }
5230       }
5231
5232       while (PyDict_Next(obj1, &dict_pos, &key, &value)) {
5233         char *key_str = PyString_AsString(key);
5234         if (strcmp(key_str, "dn") != 0) {
5235           msgel = ldb_msg_element_from_pyobject(arg2->elements, value, 0, key_str);
5236           if (msgel == NULL) {
5237             SWIG_exception(SWIG_TypeError, "unable to import element");
5238           }
5239           memcpy(&arg2->elements[msg_pos], msgel, sizeof(*msgel));
5240           msg_pos++;
5241         }
5242       }
5243
5244       if (arg2->dn == NULL) {
5245         SWIG_exception(SWIG_TypeError, "no dn set");
5246       }
5247
5248       arg2->num_elements = msg_pos;
5249     } else {
5250       if (SWIG_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_ldb_message, 0) != 0) {
5251         SWIG_exception(SWIG_TypeError, "unable to convert ldb message");
5252       }
5253     }
5254   }
5255   if (arg1 == NULL)
5256   SWIG_exception(SWIG_ValueError,
5257     "ldb context must be non-NULL");
5258   if (arg2 == NULL)
5259   SWIG_exception(SWIG_ValueError,
5260     "Message can not be None");
5261   result = ldb_add(arg1,arg2);
5262   if (result != 0) {
5263     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5264     SWIG_fail;
5265   }
5266   resultobj = Py_None;
5267   return resultobj;
5268 fail:
5269   return NULL;
5270 }
5271
5272
5273 SWIGINTERN PyObject *_wrap_Ldb_modify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5274   PyObject *resultobj = 0;
5275   ldb *arg1 = (ldb *) 0 ;
5276   ldb_msg *arg2 = (ldb_msg *) 0 ;
5277   void *argp1 = 0 ;
5278   int res1 = 0 ;
5279   void *argp2 = 0 ;
5280   int res2 = 0 ;
5281   PyObject * obj0 = 0 ;
5282   PyObject * obj1 = 0 ;
5283   char *  kwnames[] = {
5284     (char *) "self",(char *) "message", NULL
5285   };
5286   ldb_error result;
5287
5288   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_modify",kwnames,&obj0,&obj1)) SWIG_fail;
5289   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5290   if (!SWIG_IsOK(res1)) {
5291     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_modify" "', argument " "1"" of type '" "ldb *""'");
5292   }
5293   arg1 = (ldb *)(argp1);
5294   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 |  0 );
5295   if (!SWIG_IsOK(res2)) {
5296     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_modify" "', argument " "2"" of type '" "ldb_msg *""'");
5297   }
5298   arg2 = (ldb_msg *)(argp2);
5299   if (arg1 == NULL)
5300   SWIG_exception(SWIG_ValueError,
5301     "ldb context must be non-NULL");
5302   if (arg2 == NULL)
5303   SWIG_exception(SWIG_ValueError,
5304     "Message can not be None");
5305   result = ldb_modify(arg1,arg2);
5306   if (result != 0) {
5307     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5308     SWIG_fail;
5309   }
5310   resultobj = Py_None;
5311   return resultobj;
5312 fail:
5313   return NULL;
5314 }
5315
5316
5317 SWIGINTERN PyObject *_wrap_Ldb_get_config_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5318   PyObject *resultobj = 0;
5319   ldb *arg1 = (ldb *) 0 ;
5320   void *argp1 = 0 ;
5321   int res1 = 0 ;
5322   PyObject *swig_obj[1] ;
5323   ldb_dn *result = 0 ;
5324
5325   if (!args) SWIG_fail;
5326   swig_obj[0] = args;
5327   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5328   if (!SWIG_IsOK(res1)) {
5329     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_config_basedn" "', argument " "1"" of type '" "ldb *""'");
5330   }
5331   arg1 = (ldb *)(argp1);
5332   if (arg1 == NULL)
5333   SWIG_exception(SWIG_ValueError,
5334     "ldb context must be non-NULL");
5335   result = (ldb_dn *)ldb_get_config_basedn(arg1);
5336   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
5337   return resultobj;
5338 fail:
5339   return NULL;
5340 }
5341
5342
5343 SWIGINTERN PyObject *_wrap_Ldb_get_root_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5344   PyObject *resultobj = 0;
5345   ldb *arg1 = (ldb *) 0 ;
5346   void *argp1 = 0 ;
5347   int res1 = 0 ;
5348   PyObject *swig_obj[1] ;
5349   ldb_dn *result = 0 ;
5350
5351   if (!args) SWIG_fail;
5352   swig_obj[0] = args;
5353   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5354   if (!SWIG_IsOK(res1)) {
5355     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_root_basedn" "', argument " "1"" of type '" "ldb *""'");
5356   }
5357   arg1 = (ldb *)(argp1);
5358   if (arg1 == NULL)
5359   SWIG_exception(SWIG_ValueError,
5360     "ldb context must be non-NULL");
5361   result = (ldb_dn *)ldb_get_root_basedn(arg1);
5362   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
5363   return resultobj;
5364 fail:
5365   return NULL;
5366 }
5367
5368
5369 SWIGINTERN PyObject *_wrap_Ldb_get_schema_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5370   PyObject *resultobj = 0;
5371   ldb *arg1 = (ldb *) 0 ;
5372   void *argp1 = 0 ;
5373   int res1 = 0 ;
5374   PyObject *swig_obj[1] ;
5375   ldb_dn *result = 0 ;
5376
5377   if (!args) SWIG_fail;
5378   swig_obj[0] = args;
5379   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5380   if (!SWIG_IsOK(res1)) {
5381     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_schema_basedn" "', argument " "1"" of type '" "ldb *""'");
5382   }
5383   arg1 = (ldb *)(argp1);
5384   if (arg1 == NULL)
5385   SWIG_exception(SWIG_ValueError,
5386     "ldb context must be non-NULL");
5387   result = (ldb_dn *)ldb_get_schema_basedn(arg1);
5388   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
5389   return resultobj;
5390 fail:
5391   return NULL;
5392 }
5393
5394
5395 SWIGINTERN PyObject *_wrap_Ldb_get_default_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5396   PyObject *resultobj = 0;
5397   ldb *arg1 = (ldb *) 0 ;
5398   void *argp1 = 0 ;
5399   int res1 = 0 ;
5400   PyObject *swig_obj[1] ;
5401   ldb_dn *result = 0 ;
5402
5403   if (!args) SWIG_fail;
5404   swig_obj[0] = args;
5405   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5406   if (!SWIG_IsOK(res1)) {
5407     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_default_basedn" "', argument " "1"" of type '" "ldb *""'");
5408   }
5409   arg1 = (ldb *)(argp1);
5410   if (arg1 == NULL)
5411   SWIG_exception(SWIG_ValueError,
5412     "ldb context must be non-NULL");
5413   result = (ldb_dn *)ldb_get_default_basedn(arg1);
5414   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
5415   return resultobj;
5416 fail:
5417   return NULL;
5418 }
5419
5420
5421 SWIGINTERN PyObject *_wrap_Ldb_schema_format_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5422   PyObject *resultobj = 0;
5423   ldb *arg1 = (ldb *) 0 ;
5424   char *arg2 = (char *) 0 ;
5425   PyObject *arg3 = (PyObject *) 0 ;
5426   void *argp1 = 0 ;
5427   int res1 = 0 ;
5428   int res2 ;
5429   char *buf2 = 0 ;
5430   int alloc2 = 0 ;
5431   PyObject * obj0 = 0 ;
5432   PyObject * obj1 = 0 ;
5433   PyObject * obj2 = 0 ;
5434   char *  kwnames[] = {
5435     (char *) "self",(char *) "element_name",(char *) "val", NULL
5436   };
5437   PyObject *result = 0 ;
5438
5439   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_schema_format_value",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5440   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5441   if (!SWIG_IsOK(res1)) {
5442     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_format_value" "', argument " "1"" of type '" "ldb *""'");
5443   }
5444   arg1 = (ldb *)(argp1);
5445   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5446   if (!SWIG_IsOK(res2)) {
5447     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_format_value" "', argument " "2"" of type '" "char const *""'");
5448   }
5449   arg2 = (char *)(buf2);
5450   arg3 = obj2;
5451   if (arg1 == NULL)
5452   SWIG_exception(SWIG_ValueError,
5453     "ldb context must be non-NULL");
5454   result = (PyObject *)ldb_schema_format_value(arg1,(char const *)arg2,arg3);
5455   resultobj = result;
5456   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5457   return resultobj;
5458 fail:
5459   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5460   return NULL;
5461 }
5462
5463
5464 SWIGINTERN PyObject *_wrap_Ldb_errstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5465   PyObject *resultobj = 0;
5466   ldb *arg1 = (ldb *) 0 ;
5467   void *argp1 = 0 ;
5468   int res1 = 0 ;
5469   PyObject *swig_obj[1] ;
5470   char *result = 0 ;
5471
5472   if (!args) SWIG_fail;
5473   swig_obj[0] = args;
5474   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5475   if (!SWIG_IsOK(res1)) {
5476     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_errstring" "', argument " "1"" of type '" "ldb *""'");
5477   }
5478   arg1 = (ldb *)(argp1);
5479   if (arg1 == NULL)
5480   SWIG_exception(SWIG_ValueError,
5481     "ldb context must be non-NULL");
5482   result = (char *)ldb_errstring(arg1);
5483   resultobj = SWIG_FromCharPtr((const char *)result);
5484   return resultobj;
5485 fail:
5486   return NULL;
5487 }
5488
5489
5490 SWIGINTERN PyObject *_wrap_Ldb_set_create_perms(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5491   PyObject *resultobj = 0;
5492   ldb *arg1 = (ldb *) 0 ;
5493   unsigned int arg2 ;
5494   void *argp1 = 0 ;
5495   int res1 = 0 ;
5496   unsigned int val2 ;
5497   int ecode2 = 0 ;
5498   PyObject * obj0 = 0 ;
5499   PyObject * obj1 = 0 ;
5500   char *  kwnames[] = {
5501     (char *) "self",(char *) "perms", NULL
5502   };
5503
5504   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_create_perms",kwnames,&obj0,&obj1)) SWIG_fail;
5505   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5506   if (!SWIG_IsOK(res1)) {
5507     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_create_perms" "', argument " "1"" of type '" "ldb *""'");
5508   }
5509   arg1 = (ldb *)(argp1);
5510   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5511   if (!SWIG_IsOK(ecode2)) {
5512     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ldb_set_create_perms" "', argument " "2"" of type '" "unsigned int""'");
5513   }
5514   arg2 = (unsigned int)(val2);
5515   if (arg1 == NULL)
5516   SWIG_exception(SWIG_ValueError,
5517     "ldb context must be non-NULL");
5518   ldb_set_create_perms(arg1,arg2);
5519   resultobj = SWIG_Py_Void();
5520   return resultobj;
5521 fail:
5522   return NULL;
5523 }
5524
5525
5526 SWIGINTERN PyObject *_wrap_Ldb_set_modules_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5527   PyObject *resultobj = 0;
5528   ldb *arg1 = (ldb *) 0 ;
5529   char *arg2 = (char *) 0 ;
5530   void *argp1 = 0 ;
5531   int res1 = 0 ;
5532   int res2 ;
5533   char *buf2 = 0 ;
5534   int alloc2 = 0 ;
5535   PyObject * obj0 = 0 ;
5536   PyObject * obj1 = 0 ;
5537   char *  kwnames[] = {
5538     (char *) "self",(char *) "path", NULL
5539   };
5540
5541   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_modules_dir",kwnames,&obj0,&obj1)) SWIG_fail;
5542   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5543   if (!SWIG_IsOK(res1)) {
5544     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_modules_dir" "', argument " "1"" of type '" "ldb *""'");
5545   }
5546   arg1 = (ldb *)(argp1);
5547   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5548   if (!SWIG_IsOK(res2)) {
5549     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_modules_dir" "', argument " "2"" of type '" "char const *""'");
5550   }
5551   arg2 = (char *)(buf2);
5552   if (arg1 == NULL)
5553   SWIG_exception(SWIG_ValueError,
5554     "ldb context must be non-NULL");
5555   ldb_set_modules_dir(arg1,(char const *)arg2);
5556   resultobj = SWIG_Py_Void();
5557   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5558   return resultobj;
5559 fail:
5560   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5561   return NULL;
5562 }
5563
5564
5565 SWIGINTERN PyObject *_wrap_Ldb_set_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5566   PyObject *resultobj = 0;
5567   ldb *arg1 = (ldb *) 0 ;
5568   void (*arg2)(void *,enum ldb_debug_level,char const *,va_list) = (void (*)(void *,enum ldb_debug_level,char const *,va_list)) 0 ;
5569   void *arg3 = (void *) 0 ;
5570   void *argp1 = 0 ;
5571   int res1 = 0 ;
5572   PyObject * obj0 = 0 ;
5573   PyObject * obj1 = 0 ;
5574   char *  kwnames[] = {
5575     (char *) "self",(char *) "debug", NULL
5576   };
5577   ldb_error result;
5578
5579   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_debug",kwnames,&obj0,&obj1)) SWIG_fail;
5580   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5581   if (!SWIG_IsOK(res1)) {
5582     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_debug" "', argument " "1"" of type '" "ldb *""'");
5583   }
5584   arg1 = (ldb *)(argp1);
5585   arg2 = py_ldb_debug;
5586   /* FIXME: Should be decreased somewhere as well. Perhaps register a
5587          destructor and tie it to the ldb context ? */
5588   Py_INCREF(obj1);
5589   arg3 = obj1;
5590   if (arg1 == NULL)
5591   SWIG_exception(SWIG_ValueError,
5592     "ldb context must be non-NULL");
5593   result = ldb_set_debug(arg1,arg2,arg3);
5594   if (result != 0) {
5595     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5596     SWIG_fail;
5597   }
5598   resultobj = Py_None;
5599   return resultobj;
5600 fail:
5601   return NULL;
5602 }
5603
5604
5605 SWIGINTERN PyObject *_wrap_Ldb_set_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5606   PyObject *resultobj = 0;
5607   ldb *arg1 = (ldb *) 0 ;
5608   char *arg2 = (char *) 0 ;
5609   void *arg3 = (void *) 0 ;
5610   void *argp1 = 0 ;
5611   int res1 = 0 ;
5612   int res2 ;
5613   char *buf2 = 0 ;
5614   int alloc2 = 0 ;
5615   int res3 ;
5616   PyObject * obj0 = 0 ;
5617   PyObject * obj1 = 0 ;
5618   PyObject * obj2 = 0 ;
5619   char *  kwnames[] = {
5620     (char *) "self",(char *) "name",(char *) "value", NULL
5621   };
5622   ldb_error result;
5623
5624   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_set_opaque",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5625   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5626   if (!SWIG_IsOK(res1)) {
5627     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_opaque" "', argument " "1"" of type '" "ldb *""'");
5628   }
5629   arg1 = (ldb *)(argp1);
5630   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5631   if (!SWIG_IsOK(res2)) {
5632     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_opaque" "', argument " "2"" of type '" "char const *""'");
5633   }
5634   arg2 = (char *)(buf2);
5635   res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
5636   if (!SWIG_IsOK(res3)) {
5637     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ldb_set_opaque" "', argument " "3"" of type '" "void *""'");
5638   }
5639   if (arg1 == NULL)
5640   SWIG_exception(SWIG_ValueError,
5641     "ldb context must be non-NULL");
5642   result = ldb_set_opaque(arg1,(char const *)arg2,arg3);
5643   if (result != 0) {
5644     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5645     SWIG_fail;
5646   }
5647   resultobj = Py_None;
5648   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5649   return resultobj;
5650 fail:
5651   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5652   return NULL;
5653 }
5654
5655
5656 SWIGINTERN PyObject *_wrap_Ldb_get_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5657   PyObject *resultobj = 0;
5658   ldb *arg1 = (ldb *) 0 ;
5659   char *arg2 = (char *) 0 ;
5660   void *argp1 = 0 ;
5661   int res1 = 0 ;
5662   int res2 ;
5663   char *buf2 = 0 ;
5664   int alloc2 = 0 ;
5665   PyObject * obj0 = 0 ;
5666   PyObject * obj1 = 0 ;
5667   char *  kwnames[] = {
5668     (char *) "self",(char *) "name", NULL
5669   };
5670   void *result = 0 ;
5671
5672   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_get_opaque",kwnames,&obj0,&obj1)) SWIG_fail;
5673   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5674   if (!SWIG_IsOK(res1)) {
5675     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_opaque" "', argument " "1"" of type '" "ldb *""'");
5676   }
5677   arg1 = (ldb *)(argp1);
5678   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5679   if (!SWIG_IsOK(res2)) {
5680     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_get_opaque" "', argument " "2"" of type '" "char const *""'");
5681   }
5682   arg2 = (char *)(buf2);
5683   if (arg1 == NULL)
5684   SWIG_exception(SWIG_ValueError,
5685     "ldb context must be non-NULL");
5686   result = (void *)ldb_get_opaque(arg1,(char const *)arg2);
5687   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
5688   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5689   return resultobj;
5690 fail:
5691   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5692   return NULL;
5693 }
5694
5695
5696 SWIGINTERN PyObject *_wrap_Ldb_transaction_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5697   PyObject *resultobj = 0;
5698   ldb *arg1 = (ldb *) 0 ;
5699   void *argp1 = 0 ;
5700   int res1 = 0 ;
5701   PyObject *swig_obj[1] ;
5702   ldb_error result;
5703
5704   if (!args) SWIG_fail;
5705   swig_obj[0] = args;
5706   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5707   if (!SWIG_IsOK(res1)) {
5708     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_start" "', argument " "1"" of type '" "ldb *""'");
5709   }
5710   arg1 = (ldb *)(argp1);
5711   if (arg1 == NULL)
5712   SWIG_exception(SWIG_ValueError,
5713     "ldb context must be non-NULL");
5714   result = ldb_transaction_start(arg1);
5715   if (result != 0) {
5716     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5717     SWIG_fail;
5718   }
5719   resultobj = Py_None;
5720   return resultobj;
5721 fail:
5722   return NULL;
5723 }
5724
5725
5726 SWIGINTERN PyObject *_wrap_Ldb_transaction_commit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5727   PyObject *resultobj = 0;
5728   ldb *arg1 = (ldb *) 0 ;
5729   void *argp1 = 0 ;
5730   int res1 = 0 ;
5731   PyObject *swig_obj[1] ;
5732   ldb_error result;
5733
5734   if (!args) SWIG_fail;
5735   swig_obj[0] = args;
5736   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5737   if (!SWIG_IsOK(res1)) {
5738     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_commit" "', argument " "1"" of type '" "ldb *""'");
5739   }
5740   arg1 = (ldb *)(argp1);
5741   if (arg1 == NULL)
5742   SWIG_exception(SWIG_ValueError,
5743     "ldb context must be non-NULL");
5744   result = ldb_transaction_commit(arg1);
5745   if (result != 0) {
5746     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5747     SWIG_fail;
5748   }
5749   resultobj = Py_None;
5750   return resultobj;
5751 fail:
5752   return NULL;
5753 }
5754
5755
5756 SWIGINTERN PyObject *_wrap_Ldb_transaction_cancel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5757   PyObject *resultobj = 0;
5758   ldb *arg1 = (ldb *) 0 ;
5759   void *argp1 = 0 ;
5760   int res1 = 0 ;
5761   PyObject *swig_obj[1] ;
5762   ldb_error result;
5763
5764   if (!args) SWIG_fail;
5765   swig_obj[0] = args;
5766   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5767   if (!SWIG_IsOK(res1)) {
5768     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_cancel" "', argument " "1"" of type '" "ldb *""'");
5769   }
5770   arg1 = (ldb *)(argp1);
5771   if (arg1 == NULL)
5772   SWIG_exception(SWIG_ValueError,
5773     "ldb context must be non-NULL");
5774   result = ldb_transaction_cancel(arg1);
5775   if (result != 0) {
5776     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5777     SWIG_fail;
5778   }
5779   resultobj = Py_None;
5780   return resultobj;
5781 fail:
5782   return NULL;
5783 }
5784
5785
5786 SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5787   PyObject *resultobj = 0;
5788   ldb *arg1 = (ldb *) 0 ;
5789   char *arg2 = (char *) 0 ;
5790   void *argp1 = 0 ;
5791   int res1 = 0 ;
5792   int res2 ;
5793   char *buf2 = 0 ;
5794   int alloc2 = 0 ;
5795   PyObject * obj0 = 0 ;
5796   PyObject * obj1 = 0 ;
5797   char *  kwnames[] = {
5798     (char *) "self",(char *) "name", NULL
5799   };
5800
5801   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_schema_attribute_remove",kwnames,&obj0,&obj1)) SWIG_fail;
5802   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5803   if (!SWIG_IsOK(res1)) {
5804     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_remove" "', argument " "1"" of type '" "ldb *""'");
5805   }
5806   arg1 = (ldb *)(argp1);
5807   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5808   if (!SWIG_IsOK(res2)) {
5809     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_remove" "', argument " "2"" of type '" "char const *""'");
5810   }
5811   arg2 = (char *)(buf2);
5812   if (arg1 == NULL)
5813   SWIG_exception(SWIG_ValueError,
5814     "ldb context must be non-NULL");
5815   ldb_schema_attribute_remove(arg1,(char const *)arg2);
5816   resultobj = SWIG_Py_Void();
5817   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5818   return resultobj;
5819 fail:
5820   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5821   return NULL;
5822 }
5823
5824
5825 SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5826   PyObject *resultobj = 0;
5827   ldb *arg1 = (ldb *) 0 ;
5828   char *arg2 = (char *) 0 ;
5829   unsigned int arg3 ;
5830   char *arg4 = (char *) 0 ;
5831   void *argp1 = 0 ;
5832   int res1 = 0 ;
5833   int res2 ;
5834   char *buf2 = 0 ;
5835   int alloc2 = 0 ;
5836   unsigned int val3 ;
5837   int ecode3 = 0 ;
5838   int res4 ;
5839   char *buf4 = 0 ;
5840   int alloc4 = 0 ;
5841   PyObject * obj0 = 0 ;
5842   PyObject * obj1 = 0 ;
5843   PyObject * obj2 = 0 ;
5844   PyObject * obj3 = 0 ;
5845   char *  kwnames[] = {
5846     (char *) "self",(char *) "attribute",(char *) "flags",(char *) "syntax", NULL
5847   };
5848   ldb_error result;
5849
5850   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Ldb_schema_attribute_add",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5851   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5852   if (!SWIG_IsOK(res1)) {
5853     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_add" "', argument " "1"" of type '" "ldb *""'");
5854   }
5855   arg1 = (ldb *)(argp1);
5856   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5857   if (!SWIG_IsOK(res2)) {
5858     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_add" "', argument " "2"" of type '" "char const *""'");
5859   }
5860   arg2 = (char *)(buf2);
5861   ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
5862   if (!SWIG_IsOK(ecode3)) {
5863     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_schema_attribute_add" "', argument " "3"" of type '" "unsigned int""'");
5864   }
5865   arg3 = (unsigned int)(val3);
5866   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5867   if (!SWIG_IsOK(res4)) {
5868     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_schema_attribute_add" "', argument " "4"" of type '" "char const *""'");
5869   }
5870   arg4 = (char *)(buf4);
5871   if (arg1 == NULL)
5872   SWIG_exception(SWIG_ValueError,
5873     "ldb context must be non-NULL");
5874   result = ldb_schema_attribute_add(arg1,(char const *)arg2,arg3,(char const *)arg4);
5875   if (result != 0) {
5876     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5877     SWIG_fail;
5878   }
5879   resultobj = Py_None;
5880   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5881   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5882   return resultobj;
5883 fail:
5884   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5885   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5886   return NULL;
5887 }
5888
5889
5890 SWIGINTERN PyObject *_wrap_Ldb_setup_wellknown_attributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5891   PyObject *resultobj = 0;
5892   ldb *arg1 = (ldb *) 0 ;
5893   void *argp1 = 0 ;
5894   int res1 = 0 ;
5895   PyObject *swig_obj[1] ;
5896   ldb_error result;
5897
5898   if (!args) SWIG_fail;
5899   swig_obj[0] = args;
5900   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5901   if (!SWIG_IsOK(res1)) {
5902     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_setup_wellknown_attributes" "', argument " "1"" of type '" "ldb *""'");
5903   }
5904   arg1 = (ldb *)(argp1);
5905   if (arg1 == NULL)
5906   SWIG_exception(SWIG_ValueError,
5907     "ldb context must be non-NULL");
5908   result = ldb_setup_wellknown_attributes(arg1);
5909   if (result != 0) {
5910     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5911     SWIG_fail;
5912   }
5913   resultobj = Py_None;
5914   return resultobj;
5915 fail:
5916   return NULL;
5917 }
5918
5919
5920 SWIGINTERN PyObject *_wrap_Ldb___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5921   PyObject *resultobj = 0;
5922   ldb *arg1 = (ldb *) 0 ;
5923   ldb_dn *arg2 = (ldb_dn *) 0 ;
5924   struct ldb_result **arg3 = (struct ldb_result **) 0 ;
5925   void *argp1 = 0 ;
5926   int res1 = 0 ;
5927   struct ldb_result *tmp3 ;
5928   PyObject * obj0 = 0 ;
5929   PyObject * obj1 = 0 ;
5930   char *  kwnames[] = {
5931     (char *) "self",(char *) "dn", NULL
5932   };
5933   ldb_error result;
5934
5935   arg3 = &tmp3;
5936   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb___contains__",kwnames,&obj0,&obj1)) SWIG_fail;
5937   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5938   if (!SWIG_IsOK(res1)) {
5939     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___contains__" "', argument " "1"" of type '" "ldb *""'");
5940   }
5941   arg1 = (ldb *)(argp1);
5942   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
5943     SWIG_fail;
5944   }
5945   if (arg1 == NULL)
5946   SWIG_exception(SWIG_ValueError,
5947     "ldb context must be non-NULL");
5948   result = ldb___contains__(arg1,arg2,arg3);
5949   if (result != 0) {
5950     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5951     SWIG_fail;
5952   }
5953   resultobj = Py_None;
5954   resultobj = ((*arg3)->count > 0)?Py_True:Py_False;
5955   talloc_free(arg2);
5956   talloc_free(*arg3);
5957   return resultobj;
5958 fail:
5959   talloc_free(arg2);
5960   talloc_free(*arg3);
5961   return NULL;
5962 }
5963
5964
5965 SWIGINTERN PyObject *_wrap_Ldb_parse_ldif(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5966   PyObject *resultobj = 0;
5967   ldb *arg1 = (ldb *) 0 ;
5968   char *arg2 = (char *) 0 ;
5969   void *argp1 = 0 ;
5970   int res1 = 0 ;
5971   int res2 ;
5972   char *buf2 = 0 ;
5973   int alloc2 = 0 ;
5974   PyObject * obj0 = 0 ;
5975   PyObject * obj1 = 0 ;
5976   char *  kwnames[] = {
5977     (char *) "self",(char *) "s", NULL
5978   };
5979   PyObject *result = 0 ;
5980
5981   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_ldif",kwnames,&obj0,&obj1)) SWIG_fail;
5982   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5983   if (!SWIG_IsOK(res1)) {
5984     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_ldif" "', argument " "1"" of type '" "ldb *""'");
5985   }
5986   arg1 = (ldb *)(argp1);
5987   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5988   if (!SWIG_IsOK(res2)) {
5989     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_parse_ldif" "', argument " "2"" of type '" "char const *""'");
5990   }
5991   arg2 = (char *)(buf2);
5992   if (arg1 == NULL)
5993   SWIG_exception(SWIG_ValueError,
5994     "ldb context must be non-NULL");
5995   result = (PyObject *)ldb_parse_ldif(arg1,(char const *)arg2);
5996   resultobj = result;
5997   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5998   return resultobj;
5999 fail:
6000   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6001   return NULL;
6002 }
6003
6004
6005 SWIGINTERN PyObject *_wrap_Ldb___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6006   PyObject *resultobj = 0;
6007   ldb *arg1 = (ldb *) 0 ;
6008   void *argp1 = 0 ;
6009   int res1 = 0 ;
6010   PyObject *swig_obj[1] ;
6011   char *result = 0 ;
6012
6013   if (!args) SWIG_fail;
6014   swig_obj[0] = args;
6015   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
6016   if (!SWIG_IsOK(res1)) {
6017     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___repr__" "', argument " "1"" of type '" "ldb *""'");
6018   }
6019   arg1 = (ldb *)(argp1);
6020   if (arg1 == NULL)
6021   SWIG_exception(SWIG_ValueError,
6022     "ldb context must be non-NULL");
6023   result = (char *)ldb___repr__(arg1);
6024   resultobj = SWIG_FromCharPtr((const char *)result);
6025   return resultobj;
6026 fail:
6027   return NULL;
6028 }
6029
6030
6031 SWIGINTERN PyObject *Ldb_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6032   PyObject *obj;
6033   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6034   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_context, SWIG_NewClientData(obj));
6035   return SWIG_Py_Void();
6036 }
6037
6038 SWIGINTERN PyObject *Ldb_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6039   return SWIG_Python_InitShadowInstance(args);
6040 }
6041
6042 SWIGINTERN PyObject *_wrap_valid_attr_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6043   PyObject *resultobj = 0;
6044   char *arg1 = (char *) 0 ;
6045   int res1 ;
6046   char *buf1 = 0 ;
6047   int alloc1 = 0 ;
6048   PyObject * obj0 = 0 ;
6049   char *  kwnames[] = {
6050     (char *) "s", NULL
6051   };
6052   int result;
6053
6054   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:valid_attr_name",kwnames,&obj0)) SWIG_fail;
6055   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
6056   if (!SWIG_IsOK(res1)) {
6057     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "valid_attr_name" "', argument " "1"" of type '" "char const *""'");
6058   }
6059   arg1 = (char *)(buf1);
6060   result = (int)ldb_valid_attr_name((char const *)arg1);
6061   resultobj = SWIG_From_int((int)(result));
6062   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6063   return resultobj;
6064 fail:
6065   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6066   return NULL;
6067 }
6068
6069
6070 SWIGINTERN PyObject *_wrap_timestring(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6071   PyObject *resultobj = 0;
6072   time_t arg1 ;
6073   unsigned long val1 ;
6074   int ecode1 = 0 ;
6075   PyObject * obj0 = 0 ;
6076   char *  kwnames[] = {
6077     (char *) "t", NULL
6078   };
6079   char *result = 0 ;
6080
6081   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:timestring",kwnames,&obj0)) SWIG_fail;
6082   ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
6083   if (!SWIG_IsOK(ecode1)) {
6084     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "timestring" "', argument " "1"" of type '" "time_t""'");
6085   }
6086   arg1 = (time_t)(val1);
6087   result = (char *)timestring(arg1);
6088   resultobj = SWIG_FromCharPtr((const char *)result);
6089   return resultobj;
6090 fail:
6091   return NULL;
6092 }
6093
6094
6095 SWIGINTERN PyObject *_wrap_string_to_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6096   PyObject *resultobj = 0;
6097   char *arg1 = (char *) 0 ;
6098   int res1 ;
6099   char *buf1 = 0 ;
6100   int alloc1 = 0 ;
6101   PyObject * obj0 = 0 ;
6102   char *  kwnames[] = {
6103     (char *) "s", NULL
6104   };
6105   time_t result;
6106
6107   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:string_to_time",kwnames,&obj0)) SWIG_fail;
6108   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
6109   if (!SWIG_IsOK(res1)) {
6110     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_to_time" "', argument " "1"" of type '" "char const *""'");
6111   }
6112   arg1 = (char *)(buf1);
6113   result = (time_t)ldb_string_to_time((char const *)arg1);
6114   resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
6115   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6116   return resultobj;
6117 fail:
6118   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6119   return NULL;
6120 }
6121
6122
6123 SWIGINTERN PyObject *_wrap_ldb_module_prev_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6124   PyObject *resultobj = 0;
6125   ldb_module *arg1 = (ldb_module *) 0 ;
6126   struct ldb_module *arg2 = (struct ldb_module *) 0 ;
6127   void *argp1 = 0 ;
6128   int res1 = 0 ;
6129   void *argp2 = 0 ;
6130   int res2 = 0 ;
6131   PyObject *swig_obj[2] ;
6132
6133   if (!SWIG_Python_UnpackTuple(args,"ldb_module_prev_set",2,2,swig_obj)) SWIG_fail;
6134   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6135   if (!SWIG_IsOK(res1)) {
6136     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_prev_set" "', argument " "1"" of type '" "ldb_module *""'");
6137   }
6138   arg1 = (ldb_module *)(argp1);
6139   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
6140   if (!SWIG_IsOK(res2)) {
6141     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_prev_set" "', argument " "2"" of type '" "struct ldb_module *""'");
6142   }
6143   arg2 = (struct ldb_module *)(argp2);
6144   if (arg1) (arg1)->prev = arg2;
6145   resultobj = SWIG_Py_Void();
6146   return resultobj;
6147 fail:
6148   return NULL;
6149 }
6150
6151
6152 SWIGINTERN PyObject *_wrap_ldb_module_prev_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6153   PyObject *resultobj = 0;
6154   ldb_module *arg1 = (ldb_module *) 0 ;
6155   void *argp1 = 0 ;
6156   int res1 = 0 ;
6157   PyObject *swig_obj[1] ;
6158   struct ldb_module *result = 0 ;
6159
6160   if (!args) SWIG_fail;
6161   swig_obj[0] = args;
6162   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6163   if (!SWIG_IsOK(res1)) {
6164     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_prev_get" "', argument " "1"" of type '" "ldb_module *""'");
6165   }
6166   arg1 = (ldb_module *)(argp1);
6167   result = (struct ldb_module *) ((arg1)->prev);
6168   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 |  0 );
6169   return resultobj;
6170 fail:
6171   return NULL;
6172 }
6173
6174
6175 SWIGINTERN PyObject *_wrap_ldb_module_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6176   PyObject *resultobj = 0;
6177   ldb_module *arg1 = (ldb_module *) 0 ;
6178   struct ldb_module *arg2 = (struct ldb_module *) 0 ;
6179   void *argp1 = 0 ;
6180   int res1 = 0 ;
6181   void *argp2 = 0 ;
6182   int res2 = 0 ;
6183   PyObject *swig_obj[2] ;
6184
6185   if (!SWIG_Python_UnpackTuple(args,"ldb_module_next_set",2,2,swig_obj)) SWIG_fail;
6186   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6187   if (!SWIG_IsOK(res1)) {
6188     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_next_set" "', argument " "1"" of type '" "ldb_module *""'");
6189   }
6190   arg1 = (ldb_module *)(argp1);
6191   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
6192   if (!SWIG_IsOK(res2)) {
6193     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_next_set" "', argument " "2"" of type '" "struct ldb_module *""'");
6194   }
6195   arg2 = (struct ldb_module *)(argp2);
6196   if (arg1) (arg1)->next = arg2;
6197   resultobj = SWIG_Py_Void();
6198   return resultobj;
6199 fail:
6200   return NULL;
6201 }
6202
6203
6204 SWIGINTERN PyObject *_wrap_ldb_module_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6205   PyObject *resultobj = 0;
6206   ldb_module *arg1 = (ldb_module *) 0 ;
6207   void *argp1 = 0 ;
6208   int res1 = 0 ;
6209   PyObject *swig_obj[1] ;
6210   struct ldb_module *result = 0 ;
6211
6212   if (!args) SWIG_fail;
6213   swig_obj[0] = args;
6214   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6215   if (!SWIG_IsOK(res1)) {
6216     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_next_get" "', argument " "1"" of type '" "ldb_module *""'");
6217   }
6218   arg1 = (ldb_module *)(argp1);
6219   result = (struct ldb_module *) ((arg1)->next);
6220   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, 0 |  0 );
6221   return resultobj;
6222 fail:
6223   return NULL;
6224 }
6225
6226
6227 SWIGINTERN PyObject *_wrap_ldb_module___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6228   PyObject *resultobj = 0;
6229   ldb_module *arg1 = (ldb_module *) 0 ;
6230   void *argp1 = 0 ;
6231   int res1 = 0 ;
6232   PyObject *swig_obj[1] ;
6233   char *result = 0 ;
6234
6235   if (!args) SWIG_fail;
6236   swig_obj[0] = args;
6237   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6238   if (!SWIG_IsOK(res1)) {
6239     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module___str__" "', argument " "1"" of type '" "ldb_module *""'");
6240   }
6241   arg1 = (ldb_module *)(argp1);
6242   result = (char *)ldb_module___str__(arg1);
6243   resultobj = SWIG_FromCharPtr((const char *)result);
6244   return resultobj;
6245 fail:
6246   return NULL;
6247 }
6248
6249
6250 SWIGINTERN PyObject *_wrap_ldb_module___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6251   PyObject *resultobj = 0;
6252   ldb_module *arg1 = (ldb_module *) 0 ;
6253   void *argp1 = 0 ;
6254   int res1 = 0 ;
6255   PyObject *swig_obj[1] ;
6256   char *result = 0 ;
6257
6258   if (!args) SWIG_fail;
6259   swig_obj[0] = args;
6260   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6261   if (!SWIG_IsOK(res1)) {
6262     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module___repr__" "', argument " "1"" of type '" "ldb_module *""'");
6263   }
6264   arg1 = (ldb_module *)(argp1);
6265   result = (char *)ldb_module___repr__(arg1);
6266   resultobj = SWIG_FromCharPtr((const char *)result);
6267   return resultobj;
6268 fail:
6269   return NULL;
6270 }
6271
6272
6273 SWIGINTERN PyObject *_wrap_ldb_module_search(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6274   PyObject *resultobj = 0;
6275   ldb_module *arg1 = (ldb_module *) 0 ;
6276   struct ldb_dn *arg2 = (struct ldb_dn *) 0 ;
6277   enum ldb_scope arg3 ;
6278   struct ldb_parse_tree *arg4 = (struct ldb_parse_tree *) 0 ;
6279   char **arg5 = (char **) 0 ;
6280   struct ldb_result **arg6 = (struct ldb_result **) 0 ;
6281   void *argp1 = 0 ;
6282   int res1 = 0 ;
6283   void *argp2 = 0 ;
6284   int res2 = 0 ;
6285   int val3 ;
6286   int ecode3 = 0 ;
6287   void *argp4 = 0 ;
6288   int res4 = 0 ;
6289   struct ldb_result *temp_ldb_result6 ;
6290   int i6 ;
6291   PyObject * obj0 = 0 ;
6292   PyObject * obj1 = 0 ;
6293   PyObject * obj2 = 0 ;
6294   PyObject * obj3 = 0 ;
6295   PyObject * obj4 = 0 ;
6296   char *  kwnames[] = {
6297     (char *) "self",(char *) "base",(char *) "scope",(char *) "tree",(char *) "attrs", NULL
6298   };
6299   int result;
6300
6301   arg6 = &temp_ldb_result6;
6302   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:ldb_module_search",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
6303   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6304   if (!SWIG_IsOK(res1)) {
6305     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_search" "', argument " "1"" of type '" "ldb_module *""'");
6306   }
6307   arg1 = (ldb_module *)(argp1);
6308   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
6309   if (!SWIG_IsOK(res2)) {
6310     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_search" "', argument " "2"" of type '" "struct ldb_dn *""'");
6311   }
6312   arg2 = (struct ldb_dn *)(argp2);
6313   ecode3 = SWIG_AsVal_int(obj2, &val3);
6314   if (!SWIG_IsOK(ecode3)) {
6315     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ldb_module_search" "', argument " "3"" of type '" "enum ldb_scope""'");
6316   }
6317   arg3 = (enum ldb_scope)(val3);
6318   res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_ldb_parse_tree, 0 |  0 );
6319   if (!SWIG_IsOK(res4)) {
6320     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ldb_module_search" "', argument " "4"" of type '" "struct ldb_parse_tree *""'");
6321   }
6322   arg4 = (struct ldb_parse_tree *)(argp4);
6323   if (obj4 == Py_None) {
6324     arg5 = NULL;
6325   } else if (PySequence_Check(obj4)) {
6326     int i;
6327     arg5 = talloc_array(NULL, char *, PySequence_Size(obj4)+1);
6328     for(i = 0; i < PySequence_Size(obj4); i++)
6329     arg5[i] = PyString_AsString(PySequence_GetItem(obj4, i));
6330     arg5[i] = NULL;
6331   } else {
6332     SWIG_exception(SWIG_TypeError, "expected sequence");
6333   }
6334   result = (int)ldb_module_search(arg1,arg2,arg3,arg4,(char const *const *)arg5,arg6);
6335   resultobj = SWIG_From_int((int)(result));
6336   if (arg6 == NULL) {
6337     resultobj = Py_None;
6338   } else {
6339     resultobj = PyList_New((*arg6)->count);
6340     for (i6 = 0; i6 < (*arg6)->count; i6++) {
6341       PyList_SetItem(resultobj, i6,
6342         SWIG_NewPointerObj((*arg6)->msgs[i6], SWIGTYPE_p_ldb_message, 0)
6343         );
6344     }
6345   }
6346   talloc_free(arg5);
6347   return resultobj;
6348 fail:
6349   talloc_free(arg5);
6350   return NULL;
6351 }
6352
6353
6354 SWIGINTERN PyObject *_wrap_ldb_module_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6355   PyObject *resultobj = 0;
6356   ldb_module *arg1 = (ldb_module *) 0 ;
6357   struct ldb_message *arg2 = (struct ldb_message *) 0 ;
6358   void *argp1 = 0 ;
6359   int res1 = 0 ;
6360   void *argp2 = 0 ;
6361   int res2 = 0 ;
6362   PyObject * obj0 = 0 ;
6363   PyObject * obj1 = 0 ;
6364   char *  kwnames[] = {
6365     (char *) "self",(char *) "message", NULL
6366   };
6367   ldb_error result;
6368
6369   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_add",kwnames,&obj0,&obj1)) SWIG_fail;
6370   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6371   if (!SWIG_IsOK(res1)) {
6372     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_add" "', argument " "1"" of type '" "ldb_module *""'");
6373   }
6374   arg1 = (ldb_module *)(argp1);
6375   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 |  0 );
6376   if (!SWIG_IsOK(res2)) {
6377     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_add" "', argument " "2"" of type '" "struct ldb_message *""'");
6378   }
6379   arg2 = (struct ldb_message *)(argp2);
6380   result = ldb_module_add(arg1,arg2);
6381   if (result != 0) {
6382     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6383     SWIG_fail;
6384   }
6385   resultobj = Py_None;
6386   return resultobj;
6387 fail:
6388   return NULL;
6389 }
6390
6391
6392 SWIGINTERN PyObject *_wrap_ldb_module_modify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6393   PyObject *resultobj = 0;
6394   ldb_module *arg1 = (ldb_module *) 0 ;
6395   struct ldb_message *arg2 = (struct ldb_message *) 0 ;
6396   void *argp1 = 0 ;
6397   int res1 = 0 ;
6398   void *argp2 = 0 ;
6399   int res2 = 0 ;
6400   PyObject * obj0 = 0 ;
6401   PyObject * obj1 = 0 ;
6402   char *  kwnames[] = {
6403     (char *) "self",(char *) "message", NULL
6404   };
6405   ldb_error result;
6406
6407   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_modify",kwnames,&obj0,&obj1)) SWIG_fail;
6408   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6409   if (!SWIG_IsOK(res1)) {
6410     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_modify" "', argument " "1"" of type '" "ldb_module *""'");
6411   }
6412   arg1 = (ldb_module *)(argp1);
6413   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 |  0 );
6414   if (!SWIG_IsOK(res2)) {
6415     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_modify" "', argument " "2"" of type '" "struct ldb_message *""'");
6416   }
6417   arg2 = (struct ldb_message *)(argp2);
6418   result = ldb_module_modify(arg1,arg2);
6419   if (result != 0) {
6420     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6421     SWIG_fail;
6422   }
6423   resultobj = Py_None;
6424   return resultobj;
6425 fail:
6426   return NULL;
6427 }
6428
6429
6430 SWIGINTERN PyObject *_wrap_ldb_module_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6431   PyObject *resultobj = 0;
6432   ldb_module *arg1 = (ldb_module *) 0 ;
6433   struct ldb_dn *arg2 = (struct ldb_dn *) 0 ;
6434   void *argp1 = 0 ;
6435   int res1 = 0 ;
6436   void *argp2 = 0 ;
6437   int res2 = 0 ;
6438   PyObject * obj0 = 0 ;
6439   PyObject * obj1 = 0 ;
6440   char *  kwnames[] = {
6441     (char *) "self",(char *) "dn", NULL
6442   };
6443   ldb_error result;
6444
6445   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ldb_module_delete",kwnames,&obj0,&obj1)) SWIG_fail;
6446   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6447   if (!SWIG_IsOK(res1)) {
6448     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_delete" "', argument " "1"" of type '" "ldb_module *""'");
6449   }
6450   arg1 = (ldb_module *)(argp1);
6451   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
6452   if (!SWIG_IsOK(res2)) {
6453     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_delete" "', argument " "2"" of type '" "struct ldb_dn *""'");
6454   }
6455   arg2 = (struct ldb_dn *)(argp2);
6456   result = ldb_module_delete(arg1,arg2);
6457   if (result != 0) {
6458     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6459     SWIG_fail;
6460   }
6461   resultobj = Py_None;
6462   return resultobj;
6463 fail:
6464   return NULL;
6465 }
6466
6467
6468 SWIGINTERN PyObject *_wrap_ldb_module_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6469   PyObject *resultobj = 0;
6470   ldb_module *arg1 = (ldb_module *) 0 ;
6471   struct ldb_dn *arg2 = (struct ldb_dn *) 0 ;
6472   struct ldb_dn *arg3 = (struct ldb_dn *) 0 ;
6473   void *argp1 = 0 ;
6474   int res1 = 0 ;
6475   void *argp2 = 0 ;
6476   int res2 = 0 ;
6477   void *argp3 = 0 ;
6478   int res3 = 0 ;
6479   PyObject * obj0 = 0 ;
6480   PyObject * obj1 = 0 ;
6481   PyObject * obj2 = 0 ;
6482   char *  kwnames[] = {
6483     (char *) "self",(char *) "olddn",(char *) "newdn", NULL
6484   };
6485   ldb_error result;
6486
6487   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ldb_module_rename",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6488   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6489   if (!SWIG_IsOK(res1)) {
6490     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_rename" "', argument " "1"" of type '" "ldb_module *""'");
6491   }
6492   arg1 = (ldb_module *)(argp1);
6493   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
6494   if (!SWIG_IsOK(res2)) {
6495     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_module_rename" "', argument " "2"" of type '" "struct ldb_dn *""'");
6496   }
6497   arg2 = (struct ldb_dn *)(argp2);
6498   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ldb_dn, 0 |  0 );
6499   if (!SWIG_IsOK(res3)) {
6500     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ldb_module_rename" "', argument " "3"" of type '" "struct ldb_dn *""'");
6501   }
6502   arg3 = (struct ldb_dn *)(argp3);
6503   result = ldb_module_rename(arg1,arg2,arg3);
6504   if (result != 0) {
6505     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6506     SWIG_fail;
6507   }
6508   resultobj = Py_None;
6509   return resultobj;
6510 fail:
6511   return NULL;
6512 }
6513
6514
6515 SWIGINTERN PyObject *_wrap_ldb_module_start_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6516   PyObject *resultobj = 0;
6517   ldb_module *arg1 = (ldb_module *) 0 ;
6518   void *argp1 = 0 ;
6519   int res1 = 0 ;
6520   PyObject *swig_obj[1] ;
6521   ldb_error result;
6522
6523   if (!args) SWIG_fail;
6524   swig_obj[0] = args;
6525   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6526   if (!SWIG_IsOK(res1)) {
6527     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_start_transaction" "', argument " "1"" of type '" "ldb_module *""'");
6528   }
6529   arg1 = (ldb_module *)(argp1);
6530   result = ldb_module_start_transaction(arg1);
6531   if (result != 0) {
6532     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6533     SWIG_fail;
6534   }
6535   resultobj = Py_None;
6536   return resultobj;
6537 fail:
6538   return NULL;
6539 }
6540
6541
6542 SWIGINTERN PyObject *_wrap_ldb_module_end_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6543   PyObject *resultobj = 0;
6544   ldb_module *arg1 = (ldb_module *) 0 ;
6545   void *argp1 = 0 ;
6546   int res1 = 0 ;
6547   PyObject *swig_obj[1] ;
6548   ldb_error result;
6549
6550   if (!args) SWIG_fail;
6551   swig_obj[0] = args;
6552   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6553   if (!SWIG_IsOK(res1)) {
6554     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_end_transaction" "', argument " "1"" of type '" "ldb_module *""'");
6555   }
6556   arg1 = (ldb_module *)(argp1);
6557   result = ldb_module_end_transaction(arg1);
6558   if (result != 0) {
6559     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6560     SWIG_fail;
6561   }
6562   resultobj = Py_None;
6563   return resultobj;
6564 fail:
6565   return NULL;
6566 }
6567
6568
6569 SWIGINTERN PyObject *_wrap_ldb_module_del_transaction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6570   PyObject *resultobj = 0;
6571   ldb_module *arg1 = (ldb_module *) 0 ;
6572   void *argp1 = 0 ;
6573   int res1 = 0 ;
6574   PyObject *swig_obj[1] ;
6575   ldb_error result;
6576
6577   if (!args) SWIG_fail;
6578   swig_obj[0] = args;
6579   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, 0 |  0 );
6580   if (!SWIG_IsOK(res1)) {
6581     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_module_del_transaction" "', argument " "1"" of type '" "ldb_module *""'");
6582   }
6583   arg1 = (ldb_module *)(argp1);
6584   result = ldb_module_del_transaction(arg1);
6585   if (result != 0) {
6586     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
6587     SWIG_fail;
6588   }
6589   resultobj = Py_None;
6590   return resultobj;
6591 fail:
6592   return NULL;
6593 }
6594
6595
6596 SWIGINTERN PyObject *_wrap_new_ldb_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6597   PyObject *resultobj = 0;
6598   ldb_module *result = 0 ;
6599
6600   if (!SWIG_Python_UnpackTuple(args,"new_ldb_module",0,0,0)) SWIG_fail;
6601   result = (ldb_module *)calloc(1, sizeof(ldb_module));
6602   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_module, SWIG_POINTER_NEW |  0 );
6603   return resultobj;
6604 fail:
6605   return NULL;
6606 }
6607
6608
6609 SWIGINTERN PyObject *_wrap_delete_ldb_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6610   PyObject *resultobj = 0;
6611   ldb_module *arg1 = (ldb_module *) 0 ;
6612   void *argp1 = 0 ;
6613   int res1 = 0 ;
6614   PyObject *swig_obj[1] ;
6615
6616   if (!args) SWIG_fail;
6617   swig_obj[0] = args;
6618   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_module, SWIG_POINTER_DISOWN |  0 );
6619   if (!SWIG_IsOK(res1)) {
6620     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ldb_module" "', argument " "1"" of type '" "ldb_module *""'");
6621   }
6622   arg1 = (ldb_module *)(argp1);
6623   free((char *) arg1);
6624   resultobj = SWIG_Py_Void();
6625   return resultobj;
6626 fail:
6627   return NULL;
6628 }
6629
6630
6631 SWIGINTERN PyObject *ldb_module_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6632   PyObject *obj;
6633   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6634   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_module, SWIG_NewClientData(obj));
6635   return SWIG_Py_Void();
6636 }
6637
6638 SWIGINTERN PyObject *ldb_module_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6639   return SWIG_Python_InitShadowInstance(args);
6640 }
6641
6642 SWIGINTERN PyObject *_wrap_register_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6643   PyObject *resultobj = 0;
6644   struct ldb_module_ops *arg1 = (struct ldb_module_ops *) 0 ;
6645   PyObject * obj0 = 0 ;
6646   char *  kwnames[] = {
6647     (char *)"arg1", NULL
6648   };
6649   ldb_int_error result;
6650
6651   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:register_module",kwnames,&obj0)) SWIG_fail;
6652   arg1 = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
6653
6654   arg1->name = talloc_strdup(arg1, PyString_AsString(PyObject_GetAttrString(obj0, (char *)"name")));
6655
6656   Py_INCREF(obj0);
6657   arg1->private_data = obj0;
6658   arg1->init_context = py_module_init;
6659   arg1->search = py_module_search;
6660   arg1->add = py_module_add;
6661   arg1->modify = py_module_modify;
6662   arg1->del = py_module_del;
6663   arg1->rename = py_module_rename;
6664   arg1->request = py_module_request;
6665   arg1->extended = py_module_extended;
6666   arg1->start_transaction = py_module_start_transaction;
6667   arg1->end_transaction = py_module_end_transaction;
6668   arg1->del_transaction = py_module_del_transaction;
6669   arg1->wait = py_module_wait;
6670   arg1->sequence_number = py_module_sequence_number;
6671   result = ldb_register_module((struct ldb_module_ops const *)arg1);
6672   if (result != 0) {
6673     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
6674     SWIG_fail;
6675   }
6676   resultobj = Py_None;
6677   return resultobj;
6678 fail:
6679   return NULL;
6680 }
6681
6682
6683 static PyMethodDef SwigMethods[] = {
6684          { (char *)"ldb_val_to_py_object", (PyCFunction) _wrap_ldb_val_to_py_object, METH_VARARGS | METH_KEYWORDS, NULL},
6685          { (char *)"new_Dn", (PyCFunction) _wrap_new_Dn, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6686                 "S.__init__(ldb, string)\n"
6687                 "Create a new DN.\n"
6688                 ""},
6689          { (char *)"delete_Dn", (PyCFunction)_wrap_delete_Dn, METH_O, NULL},
6690          { (char *)"Dn_validate", (PyCFunction)_wrap_Dn_validate, METH_O, (char *)"\n"
6691                 "S.validate() -> bool\n"
6692                 "Validate DN is correct.\n"
6693                 ""},
6694          { (char *)"Dn_get_casefold", (PyCFunction)_wrap_Dn_get_casefold, METH_O, NULL},
6695          { (char *)"Dn___str__", (PyCFunction)_wrap_Dn___str__, METH_O, NULL},
6696          { (char *)"Dn_parent", (PyCFunction)_wrap_Dn_parent, METH_O, (char *)"\n"
6697                 "S.parent() -> dn\n"
6698                 "Get the parent for this DN.\n"
6699                 ""},
6700          { (char *)"Dn___cmp__", (PyCFunction) _wrap_Dn___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
6701          { (char *)"Dn_is_valid", (PyCFunction)_wrap_Dn_is_valid, METH_O, NULL},
6702          { (char *)"Dn_is_special", (PyCFunction)_wrap_Dn_is_special, METH_O, (char *)"\n"
6703                 "S.is_special() -> bool\n"
6704                 "Check whether this is a special LDB DN.\n"
6705                 ""},
6706          { (char *)"Dn_is_null", (PyCFunction)_wrap_Dn_is_null, METH_O, (char *)"\n"
6707                 "S.is_null() -> bool\n"
6708                 "Check whether this is a null DN.\n"
6709                 ""},
6710          { (char *)"Dn_check_special", (PyCFunction) _wrap_Dn_check_special, METH_VARARGS | METH_KEYWORDS, NULL},
6711          { (char *)"Dn___len__", (PyCFunction)_wrap_Dn___len__, METH_O, NULL},
6712          { (char *)"Dn_add_child", (PyCFunction) _wrap_Dn_add_child, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6713                 "S.add_child(dn) -> None\n"
6714                 "Add a child DN to this DN.\n"
6715                 ""},
6716          { (char *)"Dn_add_base", (PyCFunction) _wrap_Dn_add_base, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6717                 "S.add_base(dn) -> None\n"
6718                 "Add a base DN to this DN.\n"
6719                 ""},
6720          { (char *)"Dn_canonical_str", (PyCFunction)_wrap_Dn_canonical_str, METH_O, (char *)"\n"
6721                 "S.canonical_str() -> string\n"
6722                 "Canonical version of this DN (like a posix path).\n"
6723                 ""},
6724          { (char *)"Dn_canonical_ex_str", (PyCFunction)_wrap_Dn_canonical_ex_str, METH_O, (char *)"\n"
6725                 "S.canonical_ex_str() -> string\n"
6726                 "Canonical version of this DN (like a posix path, with terminating newline).\n"
6727                 ""},
6728          { (char *)"Dn___repr__", (PyCFunction)_wrap_Dn___repr__, METH_O, NULL},
6729          { (char *)"Dn___add__", (PyCFunction) _wrap_Dn___add__, METH_VARARGS | METH_KEYWORDS, NULL},
6730          { (char *)"Dn_swigregister", Dn_swigregister, METH_VARARGS, NULL},
6731          { (char *)"Dn_swiginit", Dn_swiginit, METH_VARARGS, NULL},
6732          { (char *)"MessageElement___cmp__", (PyCFunction) _wrap_MessageElement___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
6733          { (char *)"MessageElement___iter__", (PyCFunction)_wrap_MessageElement___iter__, METH_O, NULL},
6734          { (char *)"MessageElement___set__", (PyCFunction)_wrap_MessageElement___set__, METH_O, NULL},
6735          { (char *)"new_MessageElement", (PyCFunction) _wrap_new_MessageElement, METH_VARARGS | METH_KEYWORDS, (char *)"Message element."},
6736          { (char *)"MessageElement___len__", (PyCFunction)_wrap_MessageElement___len__, METH_O, NULL},
6737          { (char *)"MessageElement_get", (PyCFunction) _wrap_MessageElement_get, METH_VARARGS | METH_KEYWORDS, NULL},
6738          { (char *)"delete_MessageElement", (PyCFunction)_wrap_delete_MessageElement, METH_O, NULL},
6739          { (char *)"MessageElement_swigregister", MessageElement_swigregister, METH_VARARGS, NULL},
6740          { (char *)"MessageElement_swiginit", MessageElement_swiginit, METH_VARARGS, NULL},
6741          { (char *)"ldb_msg_list_elements", (PyCFunction) _wrap_ldb_msg_list_elements, METH_VARARGS | METH_KEYWORDS, NULL},
6742          { (char *)"Message_dn_set", _wrap_Message_dn_set, METH_VARARGS, NULL},
6743          { (char *)"Message_dn_get", (PyCFunction)_wrap_Message_dn_get, METH_O, NULL},
6744          { (char *)"new_Message", (PyCFunction) _wrap_new_Message, METH_VARARGS | METH_KEYWORDS, NULL},
6745          { (char *)"delete_Message", (PyCFunction)_wrap_delete_Message, METH_O, NULL},
6746          { (char *)"Message_find_element", (PyCFunction) _wrap_Message_find_element, METH_VARARGS | METH_KEYWORDS, NULL},
6747          { (char *)"Message___setitem__", _wrap_Message___setitem__, METH_VARARGS, NULL},
6748          { (char *)"Message___len__", (PyCFunction)_wrap_Message___len__, METH_O, NULL},
6749          { (char *)"Message_keys", (PyCFunction)_wrap_Message_keys, METH_O, NULL},
6750          { (char *)"Message___iter__", (PyCFunction)_wrap_Message___iter__, METH_O, NULL},
6751          { (char *)"Message___delitem__", (PyCFunction) _wrap_Message___delitem__, METH_VARARGS | METH_KEYWORDS, NULL},
6752          { (char *)"Message_swigregister", Message_swigregister, METH_VARARGS, NULL},
6753          { (char *)"Message_swiginit", Message_swiginit, METH_VARARGS, NULL},
6754          { (char *)"ldb_ldif_to_pyobject", (PyCFunction) _wrap_ldb_ldif_to_pyobject, METH_VARARGS | METH_KEYWORDS, NULL},
6755          { (char *)"Ldb_firstmodule_set", _wrap_Ldb_firstmodule_set, METH_VARARGS, NULL},
6756          { (char *)"Ldb_firstmodule_get", (PyCFunction)_wrap_Ldb_firstmodule_get, METH_O, NULL},
6757          { (char *)"new_Ldb", (PyCFunction)_wrap_new_Ldb, METH_NOARGS, NULL},
6758          { (char *)"Ldb_connect", (PyCFunction) _wrap_Ldb_connect, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6759                 "S.connect(url,flags=0,options=None) -> None\n"
6760                 "Connect to a LDB URL.\n"
6761                 ""},
6762          { (char *)"delete_Ldb", (PyCFunction)_wrap_delete_Ldb, METH_O, NULL},
6763          { (char *)"Ldb_search_ex", (PyCFunction) _wrap_Ldb_search_ex, METH_VARARGS | METH_KEYWORDS, NULL},
6764          { (char *)"Ldb_delete", (PyCFunction) _wrap_Ldb_delete, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6765                 "S.delete(dn) -> None\n"
6766                 "Remove an entry.\n"
6767                 ""},
6768          { (char *)"Ldb_rename", (PyCFunction) _wrap_Ldb_rename, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6769                 "S.rename(old_dn, new_dn) -> None\n"
6770                 "Rename an entry.\n"
6771                 ""},
6772          { (char *)"Ldb_parse_control_strings", (PyCFunction) _wrap_Ldb_parse_control_strings, METH_VARARGS | METH_KEYWORDS, NULL},
6773          { (char *)"Ldb_add", (PyCFunction) _wrap_Ldb_add, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6774                 "S.add(message) -> None\n"
6775                 "Add an entry.\n"
6776                 ""},
6777          { (char *)"Ldb_modify", (PyCFunction) _wrap_Ldb_modify, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6778                 "S.modify(message) -> None\n"
6779                 "Modify an entry.\n"
6780                 ""},
6781          { (char *)"Ldb_get_config_basedn", (PyCFunction)_wrap_Ldb_get_config_basedn, METH_O, NULL},
6782          { (char *)"Ldb_get_root_basedn", (PyCFunction)_wrap_Ldb_get_root_basedn, METH_O, NULL},
6783          { (char *)"Ldb_get_schema_basedn", (PyCFunction)_wrap_Ldb_get_schema_basedn, METH_O, NULL},
6784          { (char *)"Ldb_get_default_basedn", (PyCFunction)_wrap_Ldb_get_default_basedn, METH_O, NULL},
6785          { (char *)"Ldb_schema_format_value", (PyCFunction) _wrap_Ldb_schema_format_value, METH_VARARGS | METH_KEYWORDS, NULL},
6786          { (char *)"Ldb_errstring", (PyCFunction)_wrap_Ldb_errstring, METH_O, NULL},
6787          { (char *)"Ldb_set_create_perms", (PyCFunction) _wrap_Ldb_set_create_perms, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6788                 "S.set_create_perms(mode) -> None\n"
6789                 "Set mode to use when creating new LDB files.\n"
6790                 ""},
6791          { (char *)"Ldb_set_modules_dir", (PyCFunction) _wrap_Ldb_set_modules_dir, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6792                 "S.set_modules_dir(path) -> None\n"
6793                 "Set path LDB should search for modules\n"
6794                 ""},
6795          { (char *)"Ldb_set_debug", (PyCFunction) _wrap_Ldb_set_debug, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6796                 "S.set_debug(callback) -> None\n"
6797                 "Set callback for LDB debug messages.\n"
6798                 "The callback should accept a debug level and debug text.\n"
6799                 ""},
6800          { (char *)"Ldb_set_opaque", (PyCFunction) _wrap_Ldb_set_opaque, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6801                 "S.set_opaque(name, value) -> None\n"
6802                 "Set an opaque value on this LDB connection. \n"
6803                 ":note: Passing incorrect values may cause crashes.\n"
6804                 ""},
6805          { (char *)"Ldb_get_opaque", (PyCFunction) _wrap_Ldb_get_opaque, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6806                 "S.get_opaque(name) -> value\n"
6807                 "Get an opaque value set on this LDB connection. \n"
6808                 ":note: The returned value may not be useful in Python.\n"
6809                 ""},
6810          { (char *)"Ldb_transaction_start", (PyCFunction)_wrap_Ldb_transaction_start, METH_O, (char *)"\n"
6811                 "S.transaction_start() -> None\n"
6812                 "Start a new transaction.\n"
6813                 ""},
6814          { (char *)"Ldb_transaction_commit", (PyCFunction)_wrap_Ldb_transaction_commit, METH_O, (char *)"\n"
6815                 "S.transaction_commit() -> None\n"
6816                 "Commit currently active transaction.\n"
6817                 ""},
6818          { (char *)"Ldb_transaction_cancel", (PyCFunction)_wrap_Ldb_transaction_cancel, METH_O, (char *)"\n"
6819                 "S.transaction_cancel() -> None\n"
6820                 "Cancel currently active transaction.\n"
6821                 ""},
6822          { (char *)"Ldb_schema_attribute_remove", (PyCFunction) _wrap_Ldb_schema_attribute_remove, METH_VARARGS | METH_KEYWORDS, NULL},
6823          { (char *)"Ldb_schema_attribute_add", (PyCFunction) _wrap_Ldb_schema_attribute_add, METH_VARARGS | METH_KEYWORDS, NULL},
6824          { (char *)"Ldb_setup_wellknown_attributes", (PyCFunction)_wrap_Ldb_setup_wellknown_attributes, METH_O, NULL},
6825          { (char *)"Ldb___contains__", (PyCFunction) _wrap_Ldb___contains__, METH_VARARGS | METH_KEYWORDS, NULL},
6826          { (char *)"Ldb_parse_ldif", (PyCFunction) _wrap_Ldb_parse_ldif, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6827                 "S.parse_ldif(ldif) -> iter(messages)\n"
6828                 "Parse a string formatted using LDIF.\n"
6829                 ""},
6830          { (char *)"Ldb___repr__", (PyCFunction)_wrap_Ldb___repr__, METH_O, NULL},
6831          { (char *)"Ldb_swigregister", Ldb_swigregister, METH_VARARGS, NULL},
6832          { (char *)"Ldb_swiginit", Ldb_swiginit, METH_VARARGS, NULL},
6833          { (char *)"valid_attr_name", (PyCFunction) _wrap_valid_attr_name, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6834                 "S.valid_attr_name(name) -> bool\n"
6835                 "Check whether the supplied name is a valid attribute name.\n"
6836                 ""},
6837          { (char *)"timestring", (PyCFunction) _wrap_timestring, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6838                 "S.timestring(int) -> string\n"
6839                 "Generate a LDAP time string from a UNIX timestamp\n"
6840                 ""},
6841          { (char *)"string_to_time", (PyCFunction) _wrap_string_to_time, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6842                 "S.string_to_time(string) -> int\n"
6843                 "Parse a LDAP time string into a UNIX timestamp.\n"
6844                 ""},
6845          { (char *)"ldb_module_prev_set", _wrap_ldb_module_prev_set, METH_VARARGS, NULL},
6846          { (char *)"ldb_module_prev_get", (PyCFunction)_wrap_ldb_module_prev_get, METH_O, NULL},
6847          { (char *)"ldb_module_next_set", _wrap_ldb_module_next_set, METH_VARARGS, NULL},
6848          { (char *)"ldb_module_next_get", (PyCFunction)_wrap_ldb_module_next_get, METH_O, NULL},
6849          { (char *)"ldb_module___str__", (PyCFunction)_wrap_ldb_module___str__, METH_O, NULL},
6850          { (char *)"ldb_module___repr__", (PyCFunction)_wrap_ldb_module___repr__, METH_O, NULL},
6851          { (char *)"ldb_module_search", (PyCFunction) _wrap_ldb_module_search, METH_VARARGS | METH_KEYWORDS, NULL},
6852          { (char *)"ldb_module_add", (PyCFunction) _wrap_ldb_module_add, METH_VARARGS | METH_KEYWORDS, NULL},
6853          { (char *)"ldb_module_modify", (PyCFunction) _wrap_ldb_module_modify, METH_VARARGS | METH_KEYWORDS, NULL},
6854          { (char *)"ldb_module_delete", (PyCFunction) _wrap_ldb_module_delete, METH_VARARGS | METH_KEYWORDS, NULL},
6855          { (char *)"ldb_module_rename", (PyCFunction) _wrap_ldb_module_rename, METH_VARARGS | METH_KEYWORDS, NULL},
6856          { (char *)"ldb_module_start_transaction", (PyCFunction)_wrap_ldb_module_start_transaction, METH_O, NULL},
6857          { (char *)"ldb_module_end_transaction", (PyCFunction)_wrap_ldb_module_end_transaction, METH_O, NULL},
6858          { (char *)"ldb_module_del_transaction", (PyCFunction)_wrap_ldb_module_del_transaction, METH_O, NULL},
6859          { (char *)"new_ldb_module", (PyCFunction)_wrap_new_ldb_module, METH_NOARGS, NULL},
6860          { (char *)"delete_ldb_module", (PyCFunction)_wrap_delete_ldb_module, METH_O, NULL},
6861          { (char *)"ldb_module_swigregister", ldb_module_swigregister, METH_VARARGS, NULL},
6862          { (char *)"ldb_module_swiginit", ldb_module_swiginit, METH_VARARGS, NULL},
6863          { (char *)"register_module", (PyCFunction) _wrap_register_module, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
6864                 "S.register_module(module) -> None\n"
6865                 "Register a LDB module.\n"
6866                 ""},
6867          { NULL, NULL, 0, NULL }
6868 };
6869
6870
6871 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6872
6873 static swig_type_info _swigt__p_TALLOC_CTX = {"_p_TALLOC_CTX", "TALLOC_CTX *", 0, 0, (void*)0, 0};
6874 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
6875 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};
6876 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};
6877 static swig_type_info _swigt__p_ldb_context = {"_p_ldb_context", "struct ldb_context *|ldb *", 0, 0, (void*)0, 0};
6878 static swig_type_info _swigt__p_ldb_dn = {"_p_ldb_dn", "struct ldb_dn *|ldb_dn *", 0, 0, (void*)0, 0};
6879 static swig_type_info _swigt__p_ldb_ldif = {"_p_ldb_ldif", "struct ldb_ldif *|ldb_ldif *", 0, 0, (void*)0, 0};
6880 static swig_type_info _swigt__p_ldb_message = {"_p_ldb_message", "ldb_msg *|struct ldb_message *", 0, 0, (void*)0, 0};
6881 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};
6882 static swig_type_info _swigt__p_ldb_module = {"_p_ldb_module", "struct ldb_module *|ldb_module *", 0, 0, (void*)0, 0};
6883 static swig_type_info _swigt__p_ldb_module_ops = {"_p_ldb_module_ops", "struct ldb_module_ops *", 0, 0, (void*)0, 0};
6884 static swig_type_info _swigt__p_ldb_parse_tree = {"_p_ldb_parse_tree", "struct ldb_parse_tree *", 0, 0, (void*)0, 0};
6885 static swig_type_info _swigt__p_ldb_result = {"_p_ldb_result", "struct ldb_result *", 0, 0, (void*)0, 0};
6886 static swig_type_info _swigt__p_ldb_val = {"_p_ldb_val", "struct ldb_val *", 0, 0, (void*)0, 0};
6887 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};
6888 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
6889 static swig_type_info _swigt__p_p_ldb_control = {"_p_p_ldb_control", "struct ldb_control **", 0, 0, (void*)0, 0};
6890 static swig_type_info _swigt__p_p_ldb_result = {"_p_p_ldb_result", "struct ldb_result **", 0, 0, (void*)0, 0};
6891 static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
6892 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};
6893 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};
6894 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};
6895 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|time_t *", 0, 0, (void*)0, 0};
6896 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};
6897 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
6898 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
6899
6900 static swig_type_info *swig_type_initial[] = {
6901   &_swigt__p_TALLOC_CTX,
6902   &_swigt__p_char,
6903   &_swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
6904   &_swigt__p_int,
6905   &_swigt__p_ldb_context,
6906   &_swigt__p_ldb_dn,
6907   &_swigt__p_ldb_ldif,
6908   &_swigt__p_ldb_message,
6909   &_swigt__p_ldb_message_element,
6910   &_swigt__p_ldb_module,
6911   &_swigt__p_ldb_module_ops,
6912   &_swigt__p_ldb_parse_tree,
6913   &_swigt__p_ldb_result,
6914   &_swigt__p_ldb_val,
6915   &_swigt__p_long_long,
6916   &_swigt__p_p_char,
6917   &_swigt__p_p_ldb_control,
6918   &_swigt__p_p_ldb_result,
6919   &_swigt__p_short,
6920   &_swigt__p_signed_char,
6921   &_swigt__p_unsigned_char,
6922   &_swigt__p_unsigned_int,
6923   &_swigt__p_unsigned_long,
6924   &_swigt__p_unsigned_long_long,
6925   &_swigt__p_unsigned_short,
6926   &_swigt__p_void,
6927 };
6928
6929 static swig_cast_info _swigc__p_TALLOC_CTX[] = {  {&_swigt__p_TALLOC_CTX, 0, 0, 0},{0, 0, 0, 0}};
6930 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
6931 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}};
6932 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
6933 static swig_cast_info _swigc__p_ldb_context[] = {  {&_swigt__p_ldb_context, 0, 0, 0},{0, 0, 0, 0}};
6934 static swig_cast_info _swigc__p_ldb_dn[] = {  {&_swigt__p_ldb_dn, 0, 0, 0},{0, 0, 0, 0}};
6935 static swig_cast_info _swigc__p_ldb_ldif[] = {  {&_swigt__p_ldb_ldif, 0, 0, 0},{0, 0, 0, 0}};
6936 static swig_cast_info _swigc__p_ldb_message[] = {  {&_swigt__p_ldb_message, 0, 0, 0},{0, 0, 0, 0}};
6937 static swig_cast_info _swigc__p_ldb_message_element[] = {  {&_swigt__p_ldb_message_element, 0, 0, 0},{0, 0, 0, 0}};
6938 static swig_cast_info _swigc__p_ldb_module[] = {  {&_swigt__p_ldb_module, 0, 0, 0},{0, 0, 0, 0}};
6939 static swig_cast_info _swigc__p_ldb_module_ops[] = {  {&_swigt__p_ldb_module_ops, 0, 0, 0},{0, 0, 0, 0}};
6940 static swig_cast_info _swigc__p_ldb_parse_tree[] = {  {&_swigt__p_ldb_parse_tree, 0, 0, 0},{0, 0, 0, 0}};
6941 static swig_cast_info _swigc__p_ldb_result[] = {  {&_swigt__p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
6942 static swig_cast_info _swigc__p_ldb_val[] = {  {&_swigt__p_ldb_val, 0, 0, 0},{0, 0, 0, 0}};
6943 static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
6944 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
6945 static swig_cast_info _swigc__p_p_ldb_control[] = {  {&_swigt__p_p_ldb_control, 0, 0, 0},{0, 0, 0, 0}};
6946 static swig_cast_info _swigc__p_p_ldb_result[] = {  {&_swigt__p_p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
6947 static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
6948 static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
6949 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
6950 static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
6951 static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
6952 static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
6953 static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
6954 static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
6955
6956 static swig_cast_info *swig_cast_initial[] = {
6957   _swigc__p_TALLOC_CTX,
6958   _swigc__p_char,
6959   _swigc__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
6960   _swigc__p_int,
6961   _swigc__p_ldb_context,
6962   _swigc__p_ldb_dn,
6963   _swigc__p_ldb_ldif,
6964   _swigc__p_ldb_message,
6965   _swigc__p_ldb_message_element,
6966   _swigc__p_ldb_module,
6967   _swigc__p_ldb_module_ops,
6968   _swigc__p_ldb_parse_tree,
6969   _swigc__p_ldb_result,
6970   _swigc__p_ldb_val,
6971   _swigc__p_long_long,
6972   _swigc__p_p_char,
6973   _swigc__p_p_ldb_control,
6974   _swigc__p_p_ldb_result,
6975   _swigc__p_short,
6976   _swigc__p_signed_char,
6977   _swigc__p_unsigned_char,
6978   _swigc__p_unsigned_int,
6979   _swigc__p_unsigned_long,
6980   _swigc__p_unsigned_long_long,
6981   _swigc__p_unsigned_short,
6982   _swigc__p_void,
6983 };
6984
6985
6986 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6987
6988 static swig_const_info swig_const_table[] = {
6989 {0, 0, 0, 0.0, 0, 0}};
6990
6991 #ifdef __cplusplus
6992 }
6993 #endif
6994 /* -----------------------------------------------------------------------------
6995  * Type initialization:
6996  * This problem is tough by the requirement that no dynamic
6997  * memory is used. Also, since swig_type_info structures store pointers to
6998  * swig_cast_info structures and swig_cast_info structures store pointers back
6999  * to swig_type_info structures, we need some lookup code at initialization.
7000  * The idea is that swig generates all the structures that are needed.
7001  * The runtime then collects these partially filled structures.
7002  * The SWIG_InitializeModule function takes these initial arrays out of
7003  * swig_module, and does all the lookup, filling in the swig_module.types
7004  * array with the correct data and linking the correct swig_cast_info
7005  * structures together.
7006  *
7007  * The generated swig_type_info structures are assigned staticly to an initial
7008  * array. We just loop through that array, and handle each type individually.
7009  * First we lookup if this type has been already loaded, and if so, use the
7010  * loaded structure instead of the generated one. Then we have to fill in the
7011  * cast linked list. The cast data is initially stored in something like a
7012  * two-dimensional array. Each row corresponds to a type (there are the same
7013  * number of rows as there are in the swig_type_initial array). Each entry in
7014  * a column is one of the swig_cast_info structures for that type.
7015  * The cast_initial array is actually an array of arrays, because each row has
7016  * a variable number of columns. So to actually build the cast linked list,
7017  * we find the array of casts associated with the type, and loop through it
7018  * adding the casts to the list. The one last trick we need to do is making
7019  * sure the type pointer in the swig_cast_info struct is correct.
7020  *
7021  * First off, we lookup the cast->type name to see if it is already loaded.
7022  * There are three cases to handle:
7023  *  1) If the cast->type has already been loaded AND the type we are adding
7024  *     casting info to has not been loaded (it is in this module), THEN we
7025  *     replace the cast->type pointer with the type pointer that has already
7026  *     been loaded.
7027  *  2) If BOTH types (the one we are adding casting info to, and the
7028  *     cast->type) are loaded, THEN the cast info has already been loaded by
7029  *     the previous module so we just ignore it.
7030  *  3) Finally, if cast->type has not already been loaded, then we add that
7031  *     swig_cast_info to the linked list (because the cast->type) pointer will
7032  *     be correct.
7033  * ----------------------------------------------------------------------------- */
7034
7035 #ifdef __cplusplus
7036 extern "C" {
7037 #if 0
7038 } /* c-mode */
7039 #endif
7040 #endif
7041
7042 #if 0
7043 #define SWIGRUNTIME_DEBUG
7044 #endif
7045
7046
7047 SWIGRUNTIME void
7048 SWIG_InitializeModule(void *clientdata) {
7049   size_t i;
7050   swig_module_info *module_head, *iter;
7051   int found, init;
7052
7053   clientdata = clientdata;
7054
7055   /* check to see if the circular list has been setup, if not, set it up */
7056   if (swig_module.next==0) {
7057     /* Initialize the swig_module */
7058     swig_module.type_initial = swig_type_initial;
7059     swig_module.cast_initial = swig_cast_initial;
7060     swig_module.next = &swig_module;
7061     init = 1;
7062   } else {
7063     init = 0;
7064   }
7065
7066   /* Try and load any already created modules */
7067   module_head = SWIG_GetModule(clientdata);
7068   if (!module_head) {
7069     /* This is the first module loaded for this interpreter */
7070     /* so set the swig module into the interpreter */
7071     SWIG_SetModule(clientdata, &swig_module);
7072     module_head = &swig_module;
7073   } else {
7074     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
7075     found=0;
7076     iter=module_head;
7077     do {
7078       if (iter==&swig_module) {
7079         found=1;
7080         break;
7081       }
7082       iter=iter->next;
7083     } while (iter!= module_head);
7084
7085     /* if the is found in the list, then all is done and we may leave */
7086     if (found) return;
7087     /* otherwise we must add out module into the list */
7088     swig_module.next = module_head->next;
7089     module_head->next = &swig_module;
7090   }
7091
7092   /* When multiple interpeters are used, a module could have already been initialized in
7093        a different interpreter, but not yet have a pointer in this interpreter.
7094        In this case, we do not want to continue adding types... everything should be
7095        set up already */
7096   if (init == 0) return;
7097
7098   /* Now work on filling in swig_module.types */
7099 #ifdef SWIGRUNTIME_DEBUG
7100   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
7101 #endif
7102   for (i = 0; i < swig_module.size; ++i) {
7103     swig_type_info *type = 0;
7104     swig_type_info *ret;
7105     swig_cast_info *cast;
7106
7107 #ifdef SWIGRUNTIME_DEBUG
7108     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
7109 #endif
7110
7111     /* if there is another module already loaded */
7112     if (swig_module.next != &swig_module) {
7113       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
7114     }
7115     if (type) {
7116       /* Overwrite clientdata field */
7117 #ifdef SWIGRUNTIME_DEBUG
7118       printf("SWIG_InitializeModule: found type %s\n", type->name);
7119 #endif
7120       if (swig_module.type_initial[i]->clientdata) {
7121         type->clientdata = swig_module.type_initial[i]->clientdata;
7122 #ifdef SWIGRUNTIME_DEBUG
7123         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
7124 #endif
7125       }
7126     } else {
7127       type = swig_module.type_initial[i];
7128     }
7129
7130     /* Insert casting types */
7131     cast = swig_module.cast_initial[i];
7132     while (cast->type) {
7133       /* Don't need to add information already in the list */
7134       ret = 0;
7135 #ifdef SWIGRUNTIME_DEBUG
7136       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
7137 #endif
7138       if (swig_module.next != &swig_module) {
7139         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
7140 #ifdef SWIGRUNTIME_DEBUG
7141         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
7142 #endif
7143       }
7144       if (ret) {
7145         if (type == swig_module.type_initial[i]) {
7146 #ifdef SWIGRUNTIME_DEBUG
7147           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
7148 #endif
7149           cast->type = ret;
7150           ret = 0;
7151         } else {
7152           /* Check for casting already in the list */
7153           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
7154 #ifdef SWIGRUNTIME_DEBUG
7155           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
7156 #endif
7157           if (!ocast) ret = 0;
7158         }
7159       }
7160
7161       if (!ret) {
7162 #ifdef SWIGRUNTIME_DEBUG
7163         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
7164 #endif
7165         if (type->cast) {
7166           type->cast->prev = cast;
7167           cast->next = type->cast;
7168         }
7169         type->cast = cast;
7170       }
7171       cast++;
7172     }
7173     /* Set entry in modules->types array equal to the type */
7174     swig_module.types[i] = type;
7175   }
7176   swig_module.types[i] = 0;
7177
7178 #ifdef SWIGRUNTIME_DEBUG
7179   printf("**** SWIG_InitializeModule: Cast List ******\n");
7180   for (i = 0; i < swig_module.size; ++i) {
7181     int j = 0;
7182     swig_cast_info *cast = swig_module.cast_initial[i];
7183     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
7184     while (cast->type) {
7185       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
7186       cast++;
7187       ++j;
7188     }
7189     printf("---- Total casts: %d\n",j);
7190   }
7191   printf("**** SWIG_InitializeModule: Cast List ******\n");
7192 #endif
7193 }
7194
7195 /* This function will propagate the clientdata field of type to
7196 * any new swig_type_info structures that have been added into the list
7197 * of equivalent types.  It is like calling
7198 * SWIG_TypeClientData(type, clientdata) a second time.
7199 */
7200 SWIGRUNTIME void
7201 SWIG_PropagateClientData(void) {
7202   size_t i;
7203   swig_cast_info *equiv;
7204   static int init_run = 0;
7205
7206   if (init_run) return;
7207   init_run = 1;
7208
7209   for (i = 0; i < swig_module.size; i++) {
7210     if (swig_module.types[i]->clientdata) {
7211       equiv = swig_module.types[i]->cast;
7212       while (equiv) {
7213         if (!equiv->converter) {
7214           if (equiv->type && !equiv->type->clientdata)
7215           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
7216         }
7217         equiv = equiv->next;
7218       }
7219     }
7220   }
7221 }
7222
7223 #ifdef __cplusplus
7224 #if 0
7225 {
7226   /* c-mode */
7227 #endif
7228 }
7229 #endif
7230
7231
7232
7233 #ifdef __cplusplus
7234 extern "C" {
7235 #endif
7236
7237   /* Python-specific SWIG API */
7238 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
7239 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
7240 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
7241
7242   /* -----------------------------------------------------------------------------
7243    * global variable support code.
7244    * ----------------------------------------------------------------------------- */
7245
7246   typedef struct swig_globalvar {
7247     char       *name;                  /* Name of global variable */
7248     PyObject *(*get_attr)(void);       /* Return the current value */
7249     int       (*set_attr)(PyObject *); /* Set the value */
7250     struct swig_globalvar *next;
7251   } swig_globalvar;
7252
7253   typedef struct swig_varlinkobject {
7254     PyObject_HEAD
7255     swig_globalvar *vars;
7256   } swig_varlinkobject;
7257
7258   SWIGINTERN PyObject *
7259   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
7260     return PyString_FromString("<Swig global variables>");
7261   }
7262
7263   SWIGINTERN PyObject *
7264   swig_varlink_str(swig_varlinkobject *v) {
7265     PyObject *str = PyString_FromString("(");
7266     swig_globalvar  *var;
7267     for (var = v->vars; var; var=var->next) {
7268       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
7269       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
7270     }
7271     PyString_ConcatAndDel(&str,PyString_FromString(")"));
7272     return str;
7273   }
7274
7275   SWIGINTERN int
7276   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
7277     PyObject *str = swig_varlink_str(v);
7278     fprintf(fp,"Swig global variables ");
7279     fprintf(fp,"%s\n", PyString_AsString(str));
7280     Py_DECREF(str);
7281     return 0;
7282   }
7283
7284   SWIGINTERN void
7285   swig_varlink_dealloc(swig_varlinkobject *v) {
7286     swig_globalvar *var = v->vars;
7287     while (var) {
7288       swig_globalvar *n = var->next;
7289       free(var->name);
7290       free(var);
7291       var = n;
7292     }
7293   }
7294
7295   SWIGINTERN PyObject *
7296   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
7297     PyObject *res = NULL;
7298     swig_globalvar *var = v->vars;
7299     while (var) {
7300       if (strcmp(var->name,n) == 0) {
7301         res = (*var->get_attr)();
7302         break;
7303       }
7304       var = var->next;
7305     }
7306     if (res == NULL && !PyErr_Occurred()) {
7307       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
7308     }
7309     return res;
7310   }
7311
7312   SWIGINTERN int
7313   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
7314     int res = 1;
7315     swig_globalvar *var = v->vars;
7316     while (var) {
7317       if (strcmp(var->name,n) == 0) {
7318         res = (*var->set_attr)(p);
7319         break;
7320       }
7321       var = var->next;
7322     }
7323     if (res == 1 && !PyErr_Occurred()) {
7324       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
7325     }
7326     return res;
7327   }
7328
7329   SWIGINTERN PyTypeObject*
7330   swig_varlink_type(void) {
7331     static char varlink__doc__[] = "Swig var link object";
7332     static PyTypeObject varlink_type;
7333     static int type_init = 0;
7334     if (!type_init) {
7335       const PyTypeObject tmp
7336       = {
7337         PyObject_HEAD_INIT(NULL)
7338         0,                                  /* Number of items in variable part (ob_size) */
7339         (char *)"swigvarlink",              /* Type name (tp_name) */
7340         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
7341         0,                                  /* Itemsize (tp_itemsize) */
7342         (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */
7343         (printfunc) swig_varlink_print,     /* Print (tp_print) */
7344         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
7345         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
7346         0,                                  /* tp_compare */
7347         (reprfunc) swig_varlink_repr,       /* tp_repr */
7348         0,                                  /* tp_as_number */
7349         0,                                  /* tp_as_sequence */
7350         0,                                  /* tp_as_mapping */
7351         0,                                  /* tp_hash */
7352         0,                                  /* tp_call */
7353         (reprfunc)swig_varlink_str,        /* tp_str */
7354         0,                                  /* tp_getattro */
7355         0,                                  /* tp_setattro */
7356         0,                                  /* tp_as_buffer */
7357         0,                                  /* tp_flags */
7358         varlink__doc__,                     /* tp_doc */
7359         0,                                  /* tp_traverse */
7360         0,                                  /* tp_clear */
7361         0,                                  /* tp_richcompare */
7362         0,                                  /* tp_weaklistoffset */
7363 #if PY_VERSION_HEX >= 0x02020000
7364         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
7365 #endif
7366 #if PY_VERSION_HEX >= 0x02030000
7367         0,                                  /* tp_del */
7368 #endif
7369 #ifdef COUNT_ALLOCS
7370         0,0,0,0                             /* tp_alloc -> tp_next */
7371 #endif
7372       };
7373       varlink_type = tmp;
7374       varlink_type.ob_type = &PyType_Type;
7375       type_init = 1;
7376     }
7377     return &varlink_type;
7378   }
7379
7380   /* Create a variable linking object for use later */
7381   SWIGINTERN PyObject *
7382   SWIG_Python_newvarlink(void) {
7383     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
7384     if (result) {
7385       result->vars = 0;
7386     }
7387     return ((PyObject*) result);
7388   }
7389
7390   SWIGINTERN void
7391   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
7392     swig_varlinkobject *v = (swig_varlinkobject *) p;
7393     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
7394     if (gv) {
7395       size_t size = strlen(name)+1;
7396       gv->name = (char *)malloc(size);
7397       if (gv->name) {
7398         strncpy(gv->name,name,size);
7399         gv->get_attr = get_attr;
7400         gv->set_attr = set_attr;
7401         gv->next = v->vars;
7402       }
7403     }
7404     v->vars = gv;
7405   }
7406
7407   SWIGINTERN PyObject *
7408   SWIG_globals(void) {
7409     static PyObject *_SWIG_globals = 0;
7410     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
7411     return _SWIG_globals;
7412   }
7413
7414   /* -----------------------------------------------------------------------------
7415    * constants/methods manipulation
7416    * ----------------------------------------------------------------------------- */
7417
7418   /* Install Constants */
7419   SWIGINTERN void
7420   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
7421     PyObject *obj = 0;
7422     size_t i;
7423     for (i = 0; constants[i].type; ++i) {
7424       switch(constants[i].type) {
7425       case SWIG_PY_POINTER:
7426         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
7427         break;
7428       case SWIG_PY_BINARY:
7429         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
7430         break;
7431       default:
7432         obj = 0;
7433         break;
7434       }
7435       if (obj) {
7436         PyDict_SetItemString(d, constants[i].name, obj);
7437         Py_DECREF(obj);
7438       }
7439     }
7440   }
7441
7442   /* -----------------------------------------------------------------------------*/
7443   /* Fix SwigMethods to carry the callback ptrs when needed */
7444   /* -----------------------------------------------------------------------------*/
7445
7446   SWIGINTERN void
7447   SWIG_Python_FixMethods(PyMethodDef *methods,
7448     swig_const_info *const_table,
7449     swig_type_info **types,
7450     swig_type_info **types_initial) {
7451     size_t i;
7452     for (i = 0; methods[i].ml_name; ++i) {
7453       const char *c = methods[i].ml_doc;
7454       if (c && (c = strstr(c, "swig_ptr: "))) {
7455         int j;
7456         swig_const_info *ci = 0;
7457         const char *name = c + 10;
7458         for (j = 0; const_table[j].type; ++j) {
7459           if (strncmp(const_table[j].name, name,
7460               strlen(const_table[j].name)) == 0) {
7461             ci = &(const_table[j]);
7462             break;
7463           }
7464         }
7465         if (ci) {
7466           size_t shift = (ci->ptype) - types;
7467           swig_type_info *ty = types_initial[shift];
7468           size_t ldoc = (c - methods[i].ml_doc);
7469           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
7470           char *ndoc = (char*)malloc(ldoc + lptr + 10);
7471           if (ndoc) {
7472             char *buff = ndoc;
7473             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
7474             if (ptr) {
7475               strncpy(buff, methods[i].ml_doc, ldoc);
7476               buff += ldoc;
7477               strncpy(buff, "swig_ptr: ", 10);
7478               buff += 10;
7479               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
7480               methods[i].ml_doc = ndoc;
7481             }
7482           }
7483         }
7484       }
7485     }
7486   }
7487
7488 #ifdef __cplusplus
7489 }
7490 #endif
7491
7492 /* -----------------------------------------------------------------------------*
7493  *  Partial Init method
7494  * -----------------------------------------------------------------------------*/
7495
7496 #ifdef __cplusplus
7497 extern "C"
7498 #endif
7499 SWIGEXPORT void SWIG_init(void) {
7500   PyObject *m, *d;
7501
7502   /* Fix SwigMethods to carry the callback ptrs when needed */
7503   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
7504
7505   m = Py_InitModule((char *) SWIG_name, SwigMethods);
7506   d = PyModule_GetDict(m);
7507
7508   SWIG_InitializeModule(0);
7509   SWIG_InstallConstants(d,swig_const_table);
7510
7511
7512   SWIG_Python_SetConstant(d, "SCOPE_DEFAULT",SWIG_From_int((int)(LDB_SCOPE_DEFAULT)));
7513   SWIG_Python_SetConstant(d, "SCOPE_BASE",SWIG_From_int((int)(LDB_SCOPE_BASE)));
7514   SWIG_Python_SetConstant(d, "SCOPE_ONELEVEL",SWIG_From_int((int)(LDB_SCOPE_ONELEVEL)));
7515   SWIG_Python_SetConstant(d, "SCOPE_SUBTREE",SWIG_From_int((int)(LDB_SCOPE_SUBTREE)));
7516   SWIG_Python_SetConstant(d, "CHANGETYPE_NONE",SWIG_From_int((int)(LDB_CHANGETYPE_NONE)));
7517   SWIG_Python_SetConstant(d, "CHANGETYPE_ADD",SWIG_From_int((int)(LDB_CHANGETYPE_ADD)));
7518   SWIG_Python_SetConstant(d, "CHANGETYPE_DELETE",SWIG_From_int((int)(LDB_CHANGETYPE_DELETE)));
7519   SWIG_Python_SetConstant(d, "CHANGETYPE_MODIFY",SWIG_From_int((int)(LDB_CHANGETYPE_MODIFY)));
7520
7521   PyExc_LdbError = PyErr_NewException((char *)"_ldb.LdbError", NULL, NULL);
7522   PyDict_SetItemString(d, "LdbError", PyExc_LdbError);
7523
7524   SWIG_Python_SetConstant(d, "LDB_ERR_OPERATIONS_ERROR",SWIG_From_int((int)(1)));
7525   SWIG_Python_SetConstant(d, "LDB_ERR_PROTOCOL_ERROR",SWIG_From_int((int)(2)));
7526   SWIG_Python_SetConstant(d, "LDB_ERR_TIME_LIMIT_EXCEEDED",SWIG_From_int((int)(3)));
7527   SWIG_Python_SetConstant(d, "LDB_ERR_SIZE_LIMIT_EXCEEDED",SWIG_From_int((int)(4)));
7528   SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_FALSE",SWIG_From_int((int)(5)));
7529   SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_TRUE",SWIG_From_int((int)(6)));
7530   SWIG_Python_SetConstant(d, "LDB_ERR_AUTH_METHOD_NOT_SUPPORTED",SWIG_From_int((int)(7)));
7531   SWIG_Python_SetConstant(d, "LDB_ERR_STRONG_AUTH_REQUIRED",SWIG_From_int((int)(8)));
7532   SWIG_Python_SetConstant(d, "LDB_ERR_REFERRAL",SWIG_From_int((int)(10)));
7533   SWIG_Python_SetConstant(d, "LDB_ERR_ADMIN_LIMIT_EXCEEDED",SWIG_From_int((int)(11)));
7534   SWIG_Python_SetConstant(d, "LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION",SWIG_From_int((int)(12)));
7535   SWIG_Python_SetConstant(d, "LDB_ERR_CONFIDENTIALITY_REQUIRED",SWIG_From_int((int)(13)));
7536   SWIG_Python_SetConstant(d, "LDB_ERR_SASL_BIND_IN_PROGRESS",SWIG_From_int((int)(14)));
7537   SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_ATTRIBUTE",SWIG_From_int((int)(16)));
7538   SWIG_Python_SetConstant(d, "LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE",SWIG_From_int((int)(17)));
7539   SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_MATCHING",SWIG_From_int((int)(18)));
7540   SWIG_Python_SetConstant(d, "LDB_ERR_CONSTRAINT_VIOLATION",SWIG_From_int((int)(19)));
7541   SWIG_Python_SetConstant(d, "LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS",SWIG_From_int((int)(20)));
7542   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_ATTRIBUTE_SYNTAX",SWIG_From_int((int)(21)));
7543   SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_OBJECT",SWIG_From_int((int)(32)));
7544   SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_PROBLEM",SWIG_From_int((int)(33)));
7545   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_DN_SYNTAX",SWIG_From_int((int)(34)));
7546   SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_DEREFERENCING_PROBLEM",SWIG_From_int((int)(36)));
7547   SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_AUTHENTICATION",SWIG_From_int((int)(48)));
7548   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_CREDENTIALS",SWIG_From_int((int)(49)));
7549   SWIG_Python_SetConstant(d, "LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS",SWIG_From_int((int)(50)));
7550   SWIG_Python_SetConstant(d, "LDB_ERR_BUSY",SWIG_From_int((int)(51)));
7551   SWIG_Python_SetConstant(d, "LDB_ERR_UNAVAILABLE",SWIG_From_int((int)(52)));
7552   SWIG_Python_SetConstant(d, "LDB_ERR_UNWILLING_TO_PERFORM",SWIG_From_int((int)(53)));
7553   SWIG_Python_SetConstant(d, "LDB_ERR_LOOP_DETECT",SWIG_From_int((int)(54)));
7554   SWIG_Python_SetConstant(d, "LDB_ERR_NAMING_VIOLATION",SWIG_From_int((int)(64)));
7555   SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_VIOLATION",SWIG_From_int((int)(65)));
7556   SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_NON_LEAF",SWIG_From_int((int)(66)));
7557   SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_RDN",SWIG_From_int((int)(67)));
7558   SWIG_Python_SetConstant(d, "LDB_ERR_ENTRY_ALREADY_EXISTS",SWIG_From_int((int)(68)));
7559   SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED",SWIG_From_int((int)(69)));
7560   SWIG_Python_SetConstant(d, "LDB_ERR_AFFECTS_MULTIPLE_DSAS",SWIG_From_int((int)(71)));
7561   SWIG_Python_SetConstant(d, "LDB_ERR_OTHER",SWIG_From_int((int)(80)));
7562 }
7563