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_ops swig_types[9]
2496 #define SWIGTYPE_p_ldb_result swig_types[10]
2497 #define SWIGTYPE_p_ldb_val swig_types[11]
2498 #define SWIGTYPE_p_long_long swig_types[12]
2499 #define SWIGTYPE_p_p_char swig_types[13]
2500 #define SWIGTYPE_p_p_ldb_control swig_types[14]
2501 #define SWIGTYPE_p_p_ldb_result swig_types[15]
2502 #define SWIGTYPE_p_short swig_types[16]
2503 #define SWIGTYPE_p_signed_char swig_types[17]
2504 #define SWIGTYPE_p_unsigned_char swig_types[18]
2505 #define SWIGTYPE_p_unsigned_int swig_types[19]
2506 #define SWIGTYPE_p_unsigned_long swig_types[20]
2507 #define SWIGTYPE_p_unsigned_long_long swig_types[21]
2508 #define SWIGTYPE_p_unsigned_short swig_types[22]
2509 #define SWIGTYPE_p_void swig_types[23]
2510 static swig_type_info *swig_types[25];
2511 static swig_module_info swig_module = {swig_types, 24, 0, 0, 0, 0};
2512 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2513 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2514
2515 /* -------- TYPES TABLE (END) -------- */
2516
2517 #if (PY_VERSION_HEX <= 0x02000000)
2518 # if !defined(SWIG_PYTHON_CLASSIC)
2519 #  error "This python version requires swig to be run with the '-classic' option"
2520 # endif
2521 #endif
2522 #if (PY_VERSION_HEX <= 0x02020000)
2523 # error "This python version requires swig to be run with the '-nomodern' option"
2524 #endif
2525 #if (PY_VERSION_HEX <= 0x02020000)
2526 # error "This python version requires swig to be run with the '-nomodernargs' option"
2527 #endif
2528 #ifndef METH_O
2529 # error "This python version requires swig to be run with the '-nofastunpack' option"
2530 #endif
2531 #ifdef SWIG_TypeQuery
2532 # undef SWIG_TypeQuery
2533 #endif
2534 #define SWIG_TypeQuery SWIG_Python_TypeQuery
2535
2536 /*-----------------------------------------------
2537               @(target):= _ldb.so
2538   ------------------------------------------------*/
2539 #define SWIG_init    init_ldb
2540
2541 #define SWIG_name    "_ldb"
2542
2543 #define SWIGVERSION 0x010336
2544 #define SWIG_VERSION SWIGVERSION
2545
2546
2547 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2548 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2549
2550
2551
2552 #include <stdint.h>
2553 #include <stdbool.h>
2554 #include "talloc.h"
2555 #include "events.h"
2556 #include "ldb.h"
2557 #include "ldb_errors.h"
2558 #include "ldb_private.h"
2559
2560 typedef struct ldb_message ldb_msg;
2561 typedef struct ldb_context ldb;
2562 typedef struct ldb_dn ldb_dn;
2563 typedef struct ldb_ldif ldb_ldif;
2564 typedef struct ldb_message_element ldb_message_element;
2565 typedef int ldb_error;
2566 typedef int ldb_int_error;
2567
2568
2569
2570   #define SWIG_From_long   PyInt_FromLong
2571
2572
2573 SWIGINTERNINLINE PyObject *
2574 SWIG_From_int  (int value)
2575 {
2576   return SWIG_From_long  (value);
2577 }
2578
2579
2580 PyObject *ldb_val_to_py_object(struct ldb_context *ldb_ctx,
2581                                struct ldb_message_element *el,
2582                                struct ldb_val *val)
2583 {
2584         const struct ldb_schema_attribute *a;
2585         struct ldb_val new_val;
2586         TALLOC_CTX *mem_ctx = talloc_new(NULL);
2587         PyObject *ret;
2588
2589         new_val = *val;
2590
2591         if (ldb_ctx != NULL) {
2592                 a = ldb_schema_attribute_by_name(ldb_ctx, el->name);
2593
2594                 if (a != NULL) {
2595                         if (a->syntax->ldif_write_fn(ldb_ctx, mem_ctx, val, &new_val) != 0) {
2596                                 talloc_free(mem_ctx);
2597                                 return NULL;
2598                         }
2599                 }
2600         }
2601
2602         ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
2603
2604         talloc_free(mem_ctx);
2605
2606         return ret;
2607 }
2608
2609
2610
2611 SWIGINTERN swig_type_info*
2612 SWIG_pchar_descriptor(void)
2613 {
2614   static int init = 0;
2615   static swig_type_info* info = 0;
2616   if (!init) {
2617     info = SWIG_TypeQuery("_p_char");
2618     init = 1;
2619   }
2620   return info;
2621 }
2622
2623
2624 SWIGINTERN int
2625 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2626 {
2627   if (PyString_Check(obj)) {
2628     char *cstr; Py_ssize_t len;
2629     PyString_AsStringAndSize(obj, &cstr, &len);
2630     if (cptr)  {
2631       if (alloc) {
2632         /*
2633            In python the user should not be able to modify the inner
2634            string representation. To warranty that, if you define
2635            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
2636            buffer is always returned.
2637
2638            The default behavior is just to return the pointer value,
2639            so, be careful.
2640         */
2641 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
2642         if (*alloc != SWIG_OLDOBJ)
2643 #else
2644         if (*alloc == SWIG_NEWOBJ)
2645 #endif
2646           {
2647             *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
2648             *alloc = SWIG_NEWOBJ;
2649           }
2650         else {
2651           *cptr = cstr;
2652           *alloc = SWIG_OLDOBJ;
2653         }
2654       } else {
2655         *cptr = PyString_AsString(obj);
2656       }
2657     }
2658     if (psize) *psize = len + 1;
2659     return SWIG_OK;
2660   } else {
2661     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2662     if (pchar_descriptor) {
2663       void* vptr = 0;
2664       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
2665         if (cptr) *cptr = (char *) vptr;
2666         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
2667         if (alloc) *alloc = SWIG_OLDOBJ;
2668         return SWIG_OK;
2669       }
2670     }
2671   }
2672   return SWIG_TypeError;
2673 }
2674
2675
2676
2677
2678 SWIGINTERN ldb_dn *new_ldb_dn(ldb *ldb_ctx,char const *str){
2679             ldb_dn *ret = ldb_dn_new(ldb_ctx, ldb_ctx, str);
2680             /* ldb_dn_new() doesn't accept NULL as memory context, so
2681                we do it this way... */
2682             talloc_steal(NULL, ret);
2683
2684             if (ret == NULL)
2685                 SWIG_exception(SWIG_ValueError,
2686                                 "unable to parse dn string");
2687 fail:
2688             return ret;
2689         }
2690 SWIGINTERN void delete_ldb_dn(ldb_dn *self){ talloc_free(self); }
2691
2692 SWIGINTERNINLINE PyObject*
2693   SWIG_From_bool  (bool value)
2694 {
2695   return PyBool_FromLong(value ? 1 : 0);
2696 }
2697
2698
2699 SWIGINTERNINLINE PyObject *
2700 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2701 {
2702   if (carray) {
2703     if (size > INT_MAX) {
2704       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2705       return pchar_descriptor ?
2706         SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2707     } else {
2708       return PyString_FromStringAndSize(carray, (int)(size));
2709     }
2710   } else {
2711     return SWIG_Py_Void();
2712   }
2713 }
2714
2715
2716 SWIGINTERNINLINE PyObject *
2717 SWIG_FromCharPtr(const char *cptr)
2718 {
2719   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2720 }
2721
2722 SWIGINTERN ldb_dn *ldb_dn_parent(ldb_dn *self){ return ldb_dn_get_parent(NULL, self); }
2723 SWIGINTERN char const *ldb_dn_canonical_str(ldb_dn *self){
2724             return ldb_dn_canonical_string(self, self);
2725         }
2726 SWIGINTERN char const *ldb_dn_canonical_ex_str(ldb_dn *self){
2727             return ldb_dn_canonical_ex_string(self, self);
2728         }
2729 SWIGINTERN char *ldb_dn___repr__(ldb_dn *self){
2730             char *dn = ldb_dn_get_linearized(self), *ret;
2731             asprintf(&ret, "Dn('%s')", dn);
2732             talloc_free(dn);
2733             return ret;
2734         }
2735 SWIGINTERN ldb_dn *ldb_dn___add__(ldb_dn *self,ldb_dn *other){
2736             ldb_dn *ret = ldb_dn_copy(NULL, self);
2737             ldb_dn_add_child(ret, other);
2738             return ret;
2739         }
2740
2741 struct ldb_context *ldb_context_from_py_object(PyObject *py_obj)
2742 {
2743         struct ldb_context *ldb_ctx;
2744     if (SWIG_ConvertPtr(py_obj, (void *)&ldb_ctx, SWIGTYPE_p_ldb_context, 0 |  0 ) < 0)
2745         return NULL;
2746     return ldb_ctx;
2747 }
2748
2749 int ldb_dn_from_pyobject(TALLOC_CTX *mem_ctx, PyObject *object,
2750                          struct ldb_context *ldb_ctx, ldb_dn **dn)
2751 {
2752     int ret;
2753     struct ldb_dn *odn;
2754     if (ldb_ctx != NULL && PyString_Check(object)) {
2755         odn = ldb_dn_new(mem_ctx, ldb_ctx, PyString_AsString(object));
2756         if (!odn) {
2757                 return SWIG_ERROR;
2758         }
2759         *dn = odn;
2760         return 0;
2761     }
2762     ret = SWIG_ConvertPtr(object, (void **)&odn, SWIGTYPE_p_ldb_dn,
2763                            SWIG_POINTER_EXCEPTION);
2764     *dn = ldb_dn_copy(mem_ctx, odn);
2765     if (odn && !*dn) {
2766         return SWIG_ERROR;
2767     }
2768     return ret;
2769 }
2770
2771 ldb_message_element *ldb_msg_element_from_pyobject(TALLOC_CTX *mem_ctx,
2772                                                PyObject *set_obj, int flags,
2773                                                const char *attr_name)
2774 {
2775     struct ldb_message_element *me = talloc(mem_ctx, struct ldb_message_element);
2776     me->name = attr_name;
2777     me->flags = flags;
2778     if (PyString_Check(set_obj)) {
2779         me->num_values = 1;
2780         me->values = talloc_array(me, struct ldb_val, me->num_values);
2781         me->values[0].length = PyString_Size(set_obj);
2782         me->values[0].data = (uint8_t *)talloc_strdup(me->values,
2783                                            PyString_AsString(set_obj));
2784     } else if (PySequence_Check(set_obj)) {
2785         int i;
2786         me->num_values = PySequence_Size(set_obj);
2787         me->values = talloc_array(me, struct ldb_val, me->num_values);
2788         for (i = 0; i < me->num_values; i++) {
2789             PyObject *obj = PySequence_GetItem(set_obj, i);
2790             me->values[i].length = PyString_Size(obj);
2791             me->values[i].data = (uint8_t *)PyString_AsString(obj);
2792         }
2793     } else {
2794         talloc_free(me);
2795         me = NULL;
2796     }
2797
2798     return me;
2799 }
2800
2801 PyObject *ldb_msg_element_to_set(struct ldb_context *ldb_ctx,
2802                                  ldb_message_element *me)
2803 {
2804     int i;
2805     PyObject *result;
2806
2807     /* Python << 2.5 doesn't have PySet_New and PySet_Add. */
2808     result = PyList_New(me->num_values);
2809
2810     for (i = 0; i < me->num_values; i++) {
2811         PyList_SetItem(result, i,
2812             ldb_val_to_py_object(ldb_ctx, me, &me->values[i]));
2813     }
2814
2815     return result;
2816 }
2817
2818
2819 SWIGINTERN int ldb_message_element___cmp__(ldb_message_element *self,ldb_message_element *other){
2820             return ldb_msg_element_compare(self, other);
2821         }
2822 SWIGINTERN PyObject *ldb_message_element___iter__(ldb_message_element *self){
2823             return PyObject_GetIter(ldb_msg_element_to_set(NULL, self));
2824         }
2825 SWIGINTERN PyObject *ldb_message_element___set__(ldb_message_element *self){
2826             return ldb_msg_element_to_set(NULL, self);
2827         }
2828
2829 #include <limits.h>
2830 #if !defined(SWIG_NO_LLONG_MAX)
2831 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2832 #   define LLONG_MAX __LONG_LONG_MAX__
2833 #   define LLONG_MIN (-LLONG_MAX - 1LL)
2834 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2835 # endif
2836 #endif
2837
2838
2839 SWIGINTERN int
2840 SWIG_AsVal_double (PyObject *obj, double *val)
2841 {
2842   int res = SWIG_TypeError;
2843   if (PyFloat_Check(obj)) {
2844     if (val) *val = PyFloat_AsDouble(obj);
2845     return SWIG_OK;
2846   } else if (PyInt_Check(obj)) {
2847     if (val) *val = PyInt_AsLong(obj);
2848     return SWIG_OK;
2849   } else if (PyLong_Check(obj)) {
2850     double v = PyLong_AsDouble(obj);
2851     if (!PyErr_Occurred()) {
2852       if (val) *val = v;
2853       return SWIG_OK;
2854     } else {
2855       PyErr_Clear();
2856     }
2857   }
2858 #ifdef SWIG_PYTHON_CAST_MODE
2859   {
2860     int dispatch = 0;
2861     double d = PyFloat_AsDouble(obj);
2862     if (!PyErr_Occurred()) {
2863       if (val) *val = d;
2864       return SWIG_AddCast(SWIG_OK);
2865     } else {
2866       PyErr_Clear();
2867     }
2868     if (!dispatch) {
2869       long v = PyLong_AsLong(obj);
2870       if (!PyErr_Occurred()) {
2871         if (val) *val = v;
2872         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2873       } else {
2874         PyErr_Clear();
2875       }
2876     }
2877   }
2878 #endif
2879   return res;
2880 }
2881
2882
2883 #include <float.h>
2884
2885
2886 #include <math.h>
2887
2888
2889 SWIGINTERNINLINE int
2890 SWIG_CanCastAsInteger(double *d, double min, double max) {
2891   double x = *d;
2892   if ((min <= x && x <= max)) {
2893    double fx = floor(x);
2894    double cx = ceil(x);
2895    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2896    if ((errno == EDOM) || (errno == ERANGE)) {
2897      errno = 0;
2898    } else {
2899      double summ, reps, diff;
2900      if (rd < x) {
2901        diff = x - rd;
2902      } else if (rd > x) {
2903        diff = rd - x;
2904      } else {
2905        return 1;
2906      }
2907      summ = rd + x;
2908      reps = diff/summ;
2909      if (reps < 8*DBL_EPSILON) {
2910        *d = rd;
2911        return 1;
2912      }
2913    }
2914   }
2915   return 0;
2916 }
2917
2918
2919 SWIGINTERN int
2920 SWIG_AsVal_long (PyObject *obj, long* val)
2921 {
2922   if (PyInt_Check(obj)) {
2923     if (val) *val = PyInt_AsLong(obj);
2924     return SWIG_OK;
2925   } else if (PyLong_Check(obj)) {
2926     long v = PyLong_AsLong(obj);
2927     if (!PyErr_Occurred()) {
2928       if (val) *val = v;
2929       return SWIG_OK;
2930     } else {
2931       PyErr_Clear();
2932     }
2933   }
2934 #ifdef SWIG_PYTHON_CAST_MODE
2935   {
2936     int dispatch = 0;
2937     long v = PyInt_AsLong(obj);
2938     if (!PyErr_Occurred()) {
2939       if (val) *val = v;
2940       return SWIG_AddCast(SWIG_OK);
2941     } else {
2942       PyErr_Clear();
2943     }
2944     if (!dispatch) {
2945       double d;
2946       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2947       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2948         if (val) *val = (long)(d);
2949         return res;
2950       }
2951     }
2952   }
2953 #endif
2954   return SWIG_TypeError;
2955 }
2956
2957
2958 SWIGINTERN int
2959 SWIG_AsVal_int (PyObject * obj, int *val)
2960 {
2961   long v;
2962   int res = SWIG_AsVal_long (obj, &v);
2963   if (SWIG_IsOK(res)) {
2964     if ((v < INT_MIN || v > INT_MAX)) {
2965       return SWIG_OverflowError;
2966     } else {
2967       if (val) *val = (int)(v);
2968     }
2969   }
2970   return res;
2971 }
2972
2973 SWIGINTERN ldb_message_element *new_ldb_message_element(PyObject *set_obj,int flags,char const *name){
2974             return ldb_msg_element_from_pyobject(NULL, set_obj, flags, name);
2975         }
2976 SWIGINTERN int ldb_message_element___len__(ldb_message_element *self){
2977             return self->num_values;
2978         }
2979 SWIGINTERN PyObject *ldb_message_element_get(ldb_message_element *self,int i){
2980             if (i < 0 || i >= self->num_values)
2981                 return Py_None;
2982
2983             return ldb_val_to_py_object(NULL, self, &self->values[i]);
2984         }
2985 SWIGINTERN void delete_ldb_message_element(ldb_message_element *self){ talloc_free(self); }
2986
2987     PyObject *ldb_msg_list_elements(ldb_msg *msg)
2988     {
2989         int i, j = 0;
2990         PyObject *obj = PyList_New(msg->num_elements+(msg->dn != NULL?1:0));
2991         if (msg->dn != NULL) {
2992             PyList_SetItem(obj, j, PyString_FromString("dn"));
2993             j++;
2994         }
2995         for (i = 0; i < msg->num_elements; i++) {
2996             PyList_SetItem(obj, j, PyString_FromString(msg->elements[i].name));
2997             j++;
2998         }
2999         return obj;
3000     }
3001
3002 SWIGINTERN ldb_msg *new_ldb_msg(ldb_dn *dn){
3003             ldb_msg *ret = ldb_msg_new(NULL);
3004             ret->dn = talloc_reference(ret, dn);
3005             return ret;
3006         }
3007 SWIGINTERN void delete_ldb_msg(ldb_msg *self){ talloc_free(self); }
3008 SWIGINTERN void ldb_msg___setitem____SWIG_0(ldb_msg *self,char const *attr_name,ldb_message_element *val){
3009             struct ldb_message_element *el;
3010
3011             ldb_msg_remove_attr(self, attr_name);
3012
3013             el = talloc(self, struct ldb_message_element);
3014             el->name = talloc_strdup(el, attr_name);
3015             el->num_values = val->num_values;
3016             el->values = talloc_reference(el, val->values);
3017
3018             ldb_msg_add(self, el, val->flags);
3019         }
3020 SWIGINTERN void ldb_msg___setitem____SWIG_1(ldb_msg *self,char const *attr_name,PyObject *val){
3021             struct ldb_message_element *el = ldb_msg_element_from_pyobject(NULL,
3022                                                 val, 0, attr_name);
3023             talloc_steal(self, el);
3024             ldb_msg_remove_attr(self, attr_name);
3025             ldb_msg_add(self, el, el->flags);
3026         }
3027 SWIGINTERN unsigned int ldb_msg___len__(ldb_msg *self){ return self->num_elements; }
3028
3029 SWIGINTERNINLINE PyObject*
3030 SWIG_From_unsigned_SS_long  (unsigned long value)
3031 {
3032   return (value > LONG_MAX) ?
3033     PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
3034 }
3035
3036
3037 SWIGINTERNINLINE PyObject *
3038 SWIG_From_unsigned_SS_int  (unsigned int value)
3039 {
3040   return SWIG_From_unsigned_SS_long  (value);
3041 }
3042
3043 SWIGINTERN PyObject *ldb_msg_keys(ldb_msg *self){
3044             return ldb_msg_list_elements(self);
3045         }
3046 SWIGINTERN PyObject *ldb_msg___iter__(ldb_msg *self){
3047             return PyObject_GetIter(ldb_msg_list_elements(self));
3048         }
3049
3050 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3, 0);
3051
3052 static void py_ldb_debug(void *context, enum ldb_debug_level level, const char *fmt, va_list ap)
3053 {
3054     char *text;
3055     PyObject *fn = context;
3056
3057     vasprintf(&text, fmt, ap);
3058     PyObject_CallFunction(fn, (char *)"(i,s)", level, text);
3059     free(text);
3060 }
3061
3062
3063     static PyObject *ldb_ldif_to_pyobject(ldb_ldif *ldif)
3064     {
3065         if (ldif == NULL) {
3066             return Py_None;
3067         } else {
3068             return Py_BuildValue((char *)"(iO)", ldif->changetype,
3069                    SWIG_NewPointerObj(ldif->msg, SWIGTYPE_p_ldb_message, 0));
3070         }
3071     }
3072
3073
3074 PyObject *PyExc_LdbError;
3075
3076 SWIGINTERN ldb *new_ldb(){
3077             return ldb_init(NULL, event_context_init(NULL));
3078         }
3079
3080 SWIGINTERN int
3081 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3082 {
3083   if (PyInt_Check(obj)) {
3084     long v = PyInt_AsLong(obj);
3085     if (v >= 0) {
3086       if (val) *val = v;
3087       return SWIG_OK;
3088     } else {
3089       return SWIG_OverflowError;
3090     }
3091   } else if (PyLong_Check(obj)) {
3092     unsigned long v = PyLong_AsUnsignedLong(obj);
3093     if (!PyErr_Occurred()) {
3094       if (val) *val = v;
3095       return SWIG_OK;
3096     } else {
3097       PyErr_Clear();
3098     }
3099   }
3100 #ifdef SWIG_PYTHON_CAST_MODE
3101   {
3102     int dispatch = 0;
3103     unsigned long v = PyLong_AsUnsignedLong(obj);
3104     if (!PyErr_Occurred()) {
3105       if (val) *val = v;
3106       return SWIG_AddCast(SWIG_OK);
3107     } else {
3108       PyErr_Clear();
3109     }
3110     if (!dispatch) {
3111       double d;
3112       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3113       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3114         if (val) *val = (unsigned long)(d);
3115         return res;
3116       }
3117     }
3118   }
3119 #endif
3120   return SWIG_TypeError;
3121 }
3122
3123
3124 SWIGINTERN int
3125 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3126 {
3127   unsigned long v;
3128   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3129   if (SWIG_IsOK(res)) {
3130     if ((v > UINT_MAX)) {
3131       return SWIG_OverflowError;
3132     } else {
3133       if (val) *val = (unsigned int)(v);
3134     }
3135   }
3136   return res;
3137 }
3138
3139 SWIGINTERN void delete_ldb(ldb *self){ talloc_free(self); }
3140 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){
3141             int ret;
3142             struct ldb_result *res;
3143             struct ldb_request *req;
3144             res = talloc_zero(mem_ctx, struct ldb_result);
3145             if (!res) {
3146                 return 1;
3147             }
3148
3149             ret = ldb_build_search_req(&req, self, mem_ctx,
3150                            base?base:ldb_get_default_basedn(self),
3151                            scope,
3152                            expression,
3153                            attrs,
3154                            controls,
3155                            res,
3156                            ldb_search_default_callback);
3157
3158             if (ret != 0) {
3159                 talloc_free(res);
3160                 return ret;
3161             }
3162
3163             ldb_set_timeout(self, req, 0); /* use default timeout */
3164
3165             ret = ldb_request(self, req);
3166
3167             if (ret == 0) {
3168                 ret = ldb_wait(req->handle, LDB_WAIT_ALL);
3169             }
3170
3171             talloc_free(req);
3172
3173             *OUT = res;
3174             return ret;
3175         }
3176 SWIGINTERN PyObject *ldb_schema_format_value(ldb *self,char const *element_name,PyObject *val){
3177                 const struct ldb_schema_attribute *a;
3178                 struct ldb_val old_val;
3179                 struct ldb_val new_val;
3180                 TALLOC_CTX *mem_ctx = talloc_new(NULL);
3181                 PyObject *ret;
3182
3183                 old_val.data = PyString_AsString(val);
3184                 old_val.length = PyString_Size(val);
3185
3186                 a = ldb_schema_attribute_by_name(self, element_name);
3187
3188                 if (a == NULL) {
3189                         return Py_None;
3190                 }
3191
3192                 if (a->syntax->ldif_write_fn(self, mem_ctx, &old_val, &new_val) != 0) {
3193                         talloc_free(mem_ctx);
3194                         return Py_None;
3195                  }
3196
3197                 ret = PyString_FromStringAndSize((const char *)new_val.data, new_val.length);
3198
3199                 talloc_free(mem_ctx);
3200
3201                 return ret;
3202         }
3203 SWIGINTERN ldb_error ldb___contains__(ldb *self,ldb_dn *dn,struct ldb_result **result_as_bool){
3204             return ldb_search(self, dn, LDB_SCOPE_BASE, NULL, NULL,
3205                              result_as_bool);
3206         }
3207 SWIGINTERN PyObject *ldb_parse_ldif(ldb *self,char const *s){
3208             PyObject *list = PyList_New(0);
3209             struct ldb_ldif *ldif;
3210             while ((ldif = ldb_ldif_read_string(self, &s)) != NULL) {
3211                 PyList_Append(list, ldb_ldif_to_pyobject(ldif));
3212             }
3213             return PyObject_GetIter(list);
3214         }
3215 SWIGINTERN char *ldb___repr__(ldb *self){
3216             char *ret;
3217             asprintf(&ret, "<ldb connection at 0x%x>", ret);
3218             return ret;
3219         }
3220
3221 static char *timestring(time_t t)
3222 {
3223     char *tresult = ldb_timestring(NULL, t);
3224     char *result = strdup(tresult);
3225     talloc_free(tresult);
3226     return result;
3227 }
3228
3229 #ifdef __cplusplus
3230 extern "C" {
3231 #endif
3232 SWIGINTERN PyObject *_wrap_ldb_val_to_py_object(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3233   PyObject *resultobj = 0;
3234   struct ldb_context *arg1 = (struct ldb_context *) 0 ;
3235   struct ldb_message_element *arg2 = (struct ldb_message_element *) 0 ;
3236   struct ldb_val *arg3 = (struct ldb_val *) 0 ;
3237   void *argp1 = 0 ;
3238   int res1 = 0 ;
3239   void *argp2 = 0 ;
3240   int res2 = 0 ;
3241   void *argp3 = 0 ;
3242   int res3 = 0 ;
3243   PyObject * obj0 = 0 ;
3244   PyObject * obj1 = 0 ;
3245   PyObject * obj2 = 0 ;
3246   char *  kwnames[] = {
3247     (char *) "ldb_ctx",(char *) "el",(char *) "val", NULL
3248   };
3249   PyObject *result = 0 ;
3250
3251   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ldb_val_to_py_object",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3252   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
3253   if (!SWIG_IsOK(res1)) {
3254     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_val_to_py_object" "', argument " "1"" of type '" "struct ldb_context *""'");
3255   }
3256   arg1 = (struct ldb_context *)(argp1);
3257   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3258   if (!SWIG_IsOK(res2)) {
3259     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ldb_val_to_py_object" "', argument " "2"" of type '" "struct ldb_message_element *""'");
3260   }
3261   arg2 = (struct ldb_message_element *)(argp2);
3262   res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_ldb_val, 0 |  0 );
3263   if (!SWIG_IsOK(res3)) {
3264     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ldb_val_to_py_object" "', argument " "3"" of type '" "struct ldb_val *""'");
3265   }
3266   arg3 = (struct ldb_val *)(argp3);
3267   if (arg1 == NULL)
3268   SWIG_exception(SWIG_ValueError,
3269     "ldb context must be non-NULL");
3270   result = (PyObject *)ldb_val_to_py_object(arg1,arg2,arg3);
3271   resultobj = result;
3272   return resultobj;
3273 fail:
3274   return NULL;
3275 }
3276
3277
3278 SWIGINTERN PyObject *_wrap_new_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3279   PyObject *resultobj = 0;
3280   ldb *arg1 = (ldb *) 0 ;
3281   char *arg2 = (char *) 0 ;
3282   void *argp1 = 0 ;
3283   int res1 = 0 ;
3284   int res2 ;
3285   char *buf2 = 0 ;
3286   int alloc2 = 0 ;
3287   PyObject * obj0 = 0 ;
3288   PyObject * obj1 = 0 ;
3289   char *  kwnames[] = {
3290     (char *) "ldb_ctx",(char *) "str", NULL
3291   };
3292   ldb_dn *result = 0 ;
3293
3294   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_Dn",kwnames,&obj0,&obj1)) SWIG_fail;
3295   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
3296   if (!SWIG_IsOK(res1)) {
3297     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Dn" "', argument " "1"" of type '" "ldb *""'");
3298   }
3299   arg1 = (ldb *)(argp1);
3300   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3301   if (!SWIG_IsOK(res2)) {
3302     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Dn" "', argument " "2"" of type '" "char const *""'");
3303   }
3304   arg2 = (char *)(buf2);
3305   if (arg1 == NULL)
3306   SWIG_exception(SWIG_ValueError,
3307     "ldb context must be non-NULL");
3308   result = (ldb_dn *)new_ldb_dn(arg1,(char const *)arg2);
3309   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, SWIG_POINTER_NEW |  0 );
3310   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3311   return resultobj;
3312 fail:
3313   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3314   return NULL;
3315 }
3316
3317
3318 SWIGINTERN PyObject *_wrap_delete_Dn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3319   PyObject *resultobj = 0;
3320   ldb_dn *arg1 = (ldb_dn *) 0 ;
3321   void *argp1 = 0 ;
3322   int res1 = 0 ;
3323   PyObject *swig_obj[1] ;
3324
3325   if (!args) SWIG_fail;
3326   swig_obj[0] = args;
3327   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
3328   if (!SWIG_IsOK(res1)) {
3329     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Dn" "', argument " "1"" of type '" "ldb_dn *""'");
3330   }
3331   arg1 = (ldb_dn *)(argp1);
3332   delete_ldb_dn(arg1);
3333   resultobj = SWIG_Py_Void();
3334   return resultobj;
3335 fail:
3336   return NULL;
3337 }
3338
3339
3340 SWIGINTERN PyObject *_wrap_Dn_validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3341   PyObject *resultobj = 0;
3342   ldb_dn *arg1 = (ldb_dn *) 0 ;
3343   void *argp1 = 0 ;
3344   int res1 = 0 ;
3345   PyObject *swig_obj[1] ;
3346   bool result;
3347
3348   if (!args) SWIG_fail;
3349   swig_obj[0] = args;
3350   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3351   if (!SWIG_IsOK(res1)) {
3352     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_validate" "', argument " "1"" of type '" "ldb_dn *""'");
3353   }
3354   arg1 = (ldb_dn *)(argp1);
3355   result = (bool)ldb_dn_validate(arg1);
3356   resultobj = SWIG_From_bool((bool)(result));
3357   return resultobj;
3358 fail:
3359   return NULL;
3360 }
3361
3362
3363 SWIGINTERN PyObject *_wrap_Dn_get_casefold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3364   PyObject *resultobj = 0;
3365   ldb_dn *arg1 = (ldb_dn *) 0 ;
3366   void *argp1 = 0 ;
3367   int res1 = 0 ;
3368   PyObject *swig_obj[1] ;
3369   char *result = 0 ;
3370
3371   if (!args) SWIG_fail;
3372   swig_obj[0] = args;
3373   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3374   if (!SWIG_IsOK(res1)) {
3375     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_get_casefold" "', argument " "1"" of type '" "ldb_dn *""'");
3376   }
3377   arg1 = (ldb_dn *)(argp1);
3378   result = (char *)ldb_dn_get_casefold(arg1);
3379   resultobj = SWIG_FromCharPtr((const char *)result);
3380   return resultobj;
3381 fail:
3382   return NULL;
3383 }
3384
3385
3386 SWIGINTERN PyObject *_wrap_Dn___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3387   PyObject *resultobj = 0;
3388   ldb_dn *arg1 = (ldb_dn *) 0 ;
3389   void *argp1 = 0 ;
3390   int res1 = 0 ;
3391   PyObject *swig_obj[1] ;
3392   char *result = 0 ;
3393
3394   if (!args) SWIG_fail;
3395   swig_obj[0] = args;
3396   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3397   if (!SWIG_IsOK(res1)) {
3398     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___str__" "', argument " "1"" of type '" "ldb_dn *""'");
3399   }
3400   arg1 = (ldb_dn *)(argp1);
3401   result = (char *)ldb_dn_get_linearized(arg1);
3402   resultobj = SWIG_FromCharPtr((const char *)result);
3403   return resultobj;
3404 fail:
3405   return NULL;
3406 }
3407
3408
3409 SWIGINTERN PyObject *_wrap_Dn_parent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3410   PyObject *resultobj = 0;
3411   ldb_dn *arg1 = (ldb_dn *) 0 ;
3412   void *argp1 = 0 ;
3413   int res1 = 0 ;
3414   PyObject *swig_obj[1] ;
3415   ldb_dn *result = 0 ;
3416
3417   if (!args) SWIG_fail;
3418   swig_obj[0] = args;
3419   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3420   if (!SWIG_IsOK(res1)) {
3421     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_parent" "', argument " "1"" of type '" "ldb_dn *""'");
3422   }
3423   arg1 = (ldb_dn *)(argp1);
3424   result = (ldb_dn *)ldb_dn_parent(arg1);
3425   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
3426   return resultobj;
3427 fail:
3428   return NULL;
3429 }
3430
3431
3432 SWIGINTERN PyObject *_wrap_Dn___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3433   PyObject *resultobj = 0;
3434   ldb_dn *arg1 = (ldb_dn *) 0 ;
3435   ldb_dn *arg2 = (ldb_dn *) 0 ;
3436   void *argp1 = 0 ;
3437   int res1 = 0 ;
3438   void *argp2 = 0 ;
3439   int res2 = 0 ;
3440   PyObject * obj0 = 0 ;
3441   PyObject * obj1 = 0 ;
3442   char *  kwnames[] = {
3443     (char *) "self",(char *) "other", NULL
3444   };
3445   int result;
3446
3447   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
3448   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3449   if (!SWIG_IsOK(res1)) {
3450     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___cmp__" "', argument " "1"" of type '" "ldb_dn *""'");
3451   }
3452   arg1 = (ldb_dn *)(argp1);
3453   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3454   if (!SWIG_IsOK(res2)) {
3455     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___cmp__" "', argument " "2"" of type '" "ldb_dn *""'");
3456   }
3457   arg2 = (ldb_dn *)(argp2);
3458   result = (int)ldb_dn_compare(arg1,arg2);
3459   resultobj = SWIG_From_int((int)(result));
3460   return resultobj;
3461 fail:
3462   return NULL;
3463 }
3464
3465
3466 SWIGINTERN PyObject *_wrap_Dn_is_valid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3467   PyObject *resultobj = 0;
3468   ldb_dn *arg1 = (ldb_dn *) 0 ;
3469   void *argp1 = 0 ;
3470   int res1 = 0 ;
3471   PyObject *swig_obj[1] ;
3472   bool result;
3473
3474   if (!args) SWIG_fail;
3475   swig_obj[0] = args;
3476   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3477   if (!SWIG_IsOK(res1)) {
3478     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_valid" "', argument " "1"" of type '" "ldb_dn *""'");
3479   }
3480   arg1 = (ldb_dn *)(argp1);
3481   result = (bool)ldb_dn_is_valid(arg1);
3482   resultobj = SWIG_From_bool((bool)(result));
3483   return resultobj;
3484 fail:
3485   return NULL;
3486 }
3487
3488
3489 SWIGINTERN PyObject *_wrap_Dn_is_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3490   PyObject *resultobj = 0;
3491   ldb_dn *arg1 = (ldb_dn *) 0 ;
3492   void *argp1 = 0 ;
3493   int res1 = 0 ;
3494   PyObject *swig_obj[1] ;
3495   bool result;
3496
3497   if (!args) SWIG_fail;
3498   swig_obj[0] = args;
3499   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3500   if (!SWIG_IsOK(res1)) {
3501     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_special" "', argument " "1"" of type '" "ldb_dn *""'");
3502   }
3503   arg1 = (ldb_dn *)(argp1);
3504   result = (bool)ldb_dn_is_special(arg1);
3505   resultobj = SWIG_From_bool((bool)(result));
3506   return resultobj;
3507 fail:
3508   return NULL;
3509 }
3510
3511
3512 SWIGINTERN PyObject *_wrap_Dn_is_null(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3513   PyObject *resultobj = 0;
3514   ldb_dn *arg1 = (ldb_dn *) 0 ;
3515   void *argp1 = 0 ;
3516   int res1 = 0 ;
3517   PyObject *swig_obj[1] ;
3518   bool result;
3519
3520   if (!args) SWIG_fail;
3521   swig_obj[0] = args;
3522   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3523   if (!SWIG_IsOK(res1)) {
3524     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_is_null" "', argument " "1"" of type '" "ldb_dn *""'");
3525   }
3526   arg1 = (ldb_dn *)(argp1);
3527   result = (bool)ldb_dn_is_null(arg1);
3528   resultobj = SWIG_From_bool((bool)(result));
3529   return resultobj;
3530 fail:
3531   return NULL;
3532 }
3533
3534
3535 SWIGINTERN PyObject *_wrap_Dn_check_special(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3536   PyObject *resultobj = 0;
3537   ldb_dn *arg1 = (ldb_dn *) 0 ;
3538   char *arg2 = (char *) 0 ;
3539   void *argp1 = 0 ;
3540   int res1 = 0 ;
3541   int res2 ;
3542   char *buf2 = 0 ;
3543   int alloc2 = 0 ;
3544   PyObject * obj0 = 0 ;
3545   PyObject * obj1 = 0 ;
3546   char *  kwnames[] = {
3547     (char *) "self",(char *) "name", NULL
3548   };
3549   bool result;
3550
3551   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_check_special",kwnames,&obj0,&obj1)) SWIG_fail;
3552   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3553   if (!SWIG_IsOK(res1)) {
3554     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_check_special" "', argument " "1"" of type '" "ldb_dn *""'");
3555   }
3556   arg1 = (ldb_dn *)(argp1);
3557   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3558   if (!SWIG_IsOK(res2)) {
3559     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_check_special" "', argument " "2"" of type '" "char const *""'");
3560   }
3561   arg2 = (char *)(buf2);
3562   result = (bool)ldb_dn_check_special(arg1,(char const *)arg2);
3563   resultobj = SWIG_From_bool((bool)(result));
3564   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3565   return resultobj;
3566 fail:
3567   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3568   return NULL;
3569 }
3570
3571
3572 SWIGINTERN PyObject *_wrap_Dn___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3573   PyObject *resultobj = 0;
3574   ldb_dn *arg1 = (ldb_dn *) 0 ;
3575   void *argp1 = 0 ;
3576   int res1 = 0 ;
3577   PyObject *swig_obj[1] ;
3578   int result;
3579
3580   if (!args) SWIG_fail;
3581   swig_obj[0] = args;
3582   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3583   if (!SWIG_IsOK(res1)) {
3584     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___len__" "', argument " "1"" of type '" "ldb_dn *""'");
3585   }
3586   arg1 = (ldb_dn *)(argp1);
3587   result = (int)ldb_dn_get_comp_num(arg1);
3588   resultobj = SWIG_From_int((int)(result));
3589   return resultobj;
3590 fail:
3591   return NULL;
3592 }
3593
3594
3595 SWIGINTERN PyObject *_wrap_Dn_add_child(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3596   PyObject *resultobj = 0;
3597   ldb_dn *arg1 = (ldb_dn *) 0 ;
3598   ldb_dn *arg2 = (ldb_dn *) 0 ;
3599   void *argp1 = 0 ;
3600   int res1 = 0 ;
3601   void *argp2 = 0 ;
3602   int res2 = 0 ;
3603   PyObject * obj0 = 0 ;
3604   PyObject * obj1 = 0 ;
3605   char *  kwnames[] = {
3606     (char *) "self",(char *) "child", NULL
3607   };
3608   bool result;
3609
3610   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_child",kwnames,&obj0,&obj1)) SWIG_fail;
3611   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3612   if (!SWIG_IsOK(res1)) {
3613     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_child" "', argument " "1"" of type '" "ldb_dn *""'");
3614   }
3615   arg1 = (ldb_dn *)(argp1);
3616   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3617   if (!SWIG_IsOK(res2)) {
3618     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_child" "', argument " "2"" of type '" "ldb_dn *""'");
3619   }
3620   arg2 = (ldb_dn *)(argp2);
3621   result = (bool)ldb_dn_add_child(arg1,arg2);
3622   resultobj = SWIG_From_bool((bool)(result));
3623   return resultobj;
3624 fail:
3625   return NULL;
3626 }
3627
3628
3629 SWIGINTERN PyObject *_wrap_Dn_add_base(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3630   PyObject *resultobj = 0;
3631   ldb_dn *arg1 = (ldb_dn *) 0 ;
3632   ldb_dn *arg2 = (ldb_dn *) 0 ;
3633   void *argp1 = 0 ;
3634   int res1 = 0 ;
3635   void *argp2 = 0 ;
3636   int res2 = 0 ;
3637   PyObject * obj0 = 0 ;
3638   PyObject * obj1 = 0 ;
3639   char *  kwnames[] = {
3640     (char *) "self",(char *) "base", NULL
3641   };
3642   bool result;
3643
3644   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn_add_base",kwnames,&obj0,&obj1)) SWIG_fail;
3645   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3646   if (!SWIG_IsOK(res1)) {
3647     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_add_base" "', argument " "1"" of type '" "ldb_dn *""'");
3648   }
3649   arg1 = (ldb_dn *)(argp1);
3650   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3651   if (!SWIG_IsOK(res2)) {
3652     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn_add_base" "', argument " "2"" of type '" "ldb_dn *""'");
3653   }
3654   arg2 = (ldb_dn *)(argp2);
3655   result = (bool)ldb_dn_add_base(arg1,arg2);
3656   resultobj = SWIG_From_bool((bool)(result));
3657   return resultobj;
3658 fail:
3659   return NULL;
3660 }
3661
3662
3663 SWIGINTERN PyObject *_wrap_Dn_canonical_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3664   PyObject *resultobj = 0;
3665   ldb_dn *arg1 = (ldb_dn *) 0 ;
3666   void *argp1 = 0 ;
3667   int res1 = 0 ;
3668   PyObject *swig_obj[1] ;
3669   char *result = 0 ;
3670
3671   if (!args) SWIG_fail;
3672   swig_obj[0] = args;
3673   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3674   if (!SWIG_IsOK(res1)) {
3675     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_str" "', argument " "1"" of type '" "ldb_dn *""'");
3676   }
3677   arg1 = (ldb_dn *)(argp1);
3678   result = (char *)ldb_dn_canonical_str(arg1);
3679   resultobj = SWIG_FromCharPtr((const char *)result);
3680   return resultobj;
3681 fail:
3682   return NULL;
3683 }
3684
3685
3686 SWIGINTERN PyObject *_wrap_Dn_canonical_ex_str(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3687   PyObject *resultobj = 0;
3688   ldb_dn *arg1 = (ldb_dn *) 0 ;
3689   void *argp1 = 0 ;
3690   int res1 = 0 ;
3691   PyObject *swig_obj[1] ;
3692   char *result = 0 ;
3693
3694   if (!args) SWIG_fail;
3695   swig_obj[0] = args;
3696   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3697   if (!SWIG_IsOK(res1)) {
3698     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn_canonical_ex_str" "', argument " "1"" of type '" "ldb_dn *""'");
3699   }
3700   arg1 = (ldb_dn *)(argp1);
3701   result = (char *)ldb_dn_canonical_ex_str(arg1);
3702   resultobj = SWIG_FromCharPtr((const char *)result);
3703   return resultobj;
3704 fail:
3705   return NULL;
3706 }
3707
3708
3709 SWIGINTERN PyObject *_wrap_Dn___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3710   PyObject *resultobj = 0;
3711   ldb_dn *arg1 = (ldb_dn *) 0 ;
3712   void *argp1 = 0 ;
3713   int res1 = 0 ;
3714   PyObject *swig_obj[1] ;
3715   char *result = 0 ;
3716
3717   if (!args) SWIG_fail;
3718   swig_obj[0] = args;
3719   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3720   if (!SWIG_IsOK(res1)) {
3721     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___repr__" "', argument " "1"" of type '" "ldb_dn *""'");
3722   }
3723   arg1 = (ldb_dn *)(argp1);
3724   result = (char *)ldb_dn___repr__(arg1);
3725   resultobj = SWIG_FromCharPtr((const char *)result);
3726   return resultobj;
3727 fail:
3728   return NULL;
3729 }
3730
3731
3732 SWIGINTERN PyObject *_wrap_Dn___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3733   PyObject *resultobj = 0;
3734   ldb_dn *arg1 = (ldb_dn *) 0 ;
3735   ldb_dn *arg2 = (ldb_dn *) 0 ;
3736   void *argp1 = 0 ;
3737   int res1 = 0 ;
3738   void *argp2 = 0 ;
3739   int res2 = 0 ;
3740   PyObject * obj0 = 0 ;
3741   PyObject * obj1 = 0 ;
3742   char *  kwnames[] = {
3743     (char *) "self",(char *) "other", NULL
3744   };
3745   ldb_dn *result = 0 ;
3746
3747   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Dn___add__",kwnames,&obj0,&obj1)) SWIG_fail;
3748   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
3749   if (!SWIG_IsOK(res1)) {
3750     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dn___add__" "', argument " "1"" of type '" "ldb_dn *""'");
3751   }
3752   arg1 = (ldb_dn *)(argp1);
3753   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_dn, 0 |  0 );
3754   if (!SWIG_IsOK(res2)) {
3755     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dn___add__" "', argument " "2"" of type '" "ldb_dn *""'");
3756   }
3757   arg2 = (ldb_dn *)(argp2);
3758   result = (ldb_dn *)ldb_dn___add__(arg1,arg2);
3759   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
3760   return resultobj;
3761 fail:
3762   return NULL;
3763 }
3764
3765
3766 SWIGINTERN PyObject *Dn_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3767   PyObject *obj;
3768   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3769   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_dn, SWIG_NewClientData(obj));
3770   return SWIG_Py_Void();
3771 }
3772
3773 SWIGINTERN PyObject *Dn_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3774   return SWIG_Python_InitShadowInstance(args);
3775 }
3776
3777 SWIGINTERN PyObject *_wrap_MessageElement___cmp__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3778   PyObject *resultobj = 0;
3779   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3780   ldb_message_element *arg2 = (ldb_message_element *) 0 ;
3781   void *argp1 = 0 ;
3782   int res1 = 0 ;
3783   void *argp2 = 0 ;
3784   int res2 = 0 ;
3785   PyObject * obj0 = 0 ;
3786   PyObject * obj1 = 0 ;
3787   char *  kwnames[] = {
3788     (char *) "self",(char *) "other", NULL
3789   };
3790   int result;
3791
3792   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MessageElement___cmp__",kwnames,&obj0,&obj1)) SWIG_fail;
3793   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3794   if (!SWIG_IsOK(res1)) {
3795     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___cmp__" "', argument " "1"" of type '" "ldb_message_element *""'");
3796   }
3797   arg1 = (ldb_message_element *)(argp1);
3798   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3799   if (!SWIG_IsOK(res2)) {
3800     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MessageElement___cmp__" "', argument " "2"" of type '" "ldb_message_element *""'");
3801   }
3802   arg2 = (ldb_message_element *)(argp2);
3803   result = (int)ldb_message_element___cmp__(arg1,arg2);
3804   resultobj = SWIG_From_int((int)(result));
3805   return resultobj;
3806 fail:
3807   return NULL;
3808 }
3809
3810
3811 SWIGINTERN PyObject *_wrap_MessageElement___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3812   PyObject *resultobj = 0;
3813   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3814   void *argp1 = 0 ;
3815   int res1 = 0 ;
3816   PyObject *swig_obj[1] ;
3817   PyObject *result = 0 ;
3818
3819   if (!args) SWIG_fail;
3820   swig_obj[0] = args;
3821   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3822   if (!SWIG_IsOK(res1)) {
3823     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___iter__" "', argument " "1"" of type '" "ldb_message_element *""'");
3824   }
3825   arg1 = (ldb_message_element *)(argp1);
3826   result = (PyObject *)ldb_message_element___iter__(arg1);
3827   resultobj = result;
3828   return resultobj;
3829 fail:
3830   return NULL;
3831 }
3832
3833
3834 SWIGINTERN PyObject *_wrap_MessageElement___set__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3835   PyObject *resultobj = 0;
3836   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3837   void *argp1 = 0 ;
3838   int res1 = 0 ;
3839   PyObject *swig_obj[1] ;
3840   PyObject *result = 0 ;
3841
3842   if (!args) SWIG_fail;
3843   swig_obj[0] = args;
3844   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3845   if (!SWIG_IsOK(res1)) {
3846     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___set__" "', argument " "1"" of type '" "ldb_message_element *""'");
3847   }
3848   arg1 = (ldb_message_element *)(argp1);
3849   result = (PyObject *)ldb_message_element___set__(arg1);
3850   resultobj = result;
3851   return resultobj;
3852 fail:
3853   return NULL;
3854 }
3855
3856
3857 SWIGINTERN PyObject *_wrap_new_MessageElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3858   PyObject *resultobj = 0;
3859   PyObject *arg1 = (PyObject *) 0 ;
3860   int arg2 = (int) 0 ;
3861   char *arg3 = (char *) NULL ;
3862   int val2 ;
3863   int ecode2 = 0 ;
3864   int res3 ;
3865   char *buf3 = 0 ;
3866   int alloc3 = 0 ;
3867   PyObject * obj0 = 0 ;
3868   PyObject * obj1 = 0 ;
3869   PyObject * obj2 = 0 ;
3870   char *  kwnames[] = {
3871     (char *) "set_obj",(char *) "flags",(char *) "name", NULL
3872   };
3873   ldb_message_element *result = 0 ;
3874
3875   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_MessageElement",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
3876   arg1 = obj0;
3877   if (obj1) {
3878     ecode2 = SWIG_AsVal_int(obj1, &val2);
3879     if (!SWIG_IsOK(ecode2)) {
3880       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MessageElement" "', argument " "2"" of type '" "int""'");
3881     }
3882     arg2 = (int)(val2);
3883   }
3884   if (obj2) {
3885     res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3886     if (!SWIG_IsOK(res3)) {
3887       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MessageElement" "', argument " "3"" of type '" "char const *""'");
3888     }
3889     arg3 = (char *)(buf3);
3890   }
3891   result = (ldb_message_element *)new_ldb_message_element(arg1,arg2,(char const *)arg3);
3892   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message_element, SWIG_POINTER_NEW |  0 );
3893   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3894   return resultobj;
3895 fail:
3896   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3897   return NULL;
3898 }
3899
3900
3901 SWIGINTERN PyObject *_wrap_MessageElement___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3902   PyObject *resultobj = 0;
3903   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3904   void *argp1 = 0 ;
3905   int res1 = 0 ;
3906   PyObject *swig_obj[1] ;
3907   int result;
3908
3909   if (!args) SWIG_fail;
3910   swig_obj[0] = args;
3911   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3912   if (!SWIG_IsOK(res1)) {
3913     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement___len__" "', argument " "1"" of type '" "ldb_message_element *""'");
3914   }
3915   arg1 = (ldb_message_element *)(argp1);
3916   result = (int)ldb_message_element___len__(arg1);
3917   resultobj = SWIG_From_int((int)(result));
3918   return resultobj;
3919 fail:
3920   return NULL;
3921 }
3922
3923
3924 SWIGINTERN PyObject *_wrap_MessageElement_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3925   PyObject *resultobj = 0;
3926   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3927   int arg2 ;
3928   void *argp1 = 0 ;
3929   int res1 = 0 ;
3930   int val2 ;
3931   int ecode2 = 0 ;
3932   PyObject * obj0 = 0 ;
3933   PyObject * obj1 = 0 ;
3934   char *  kwnames[] = {
3935     (char *) "self",(char *) "i", NULL
3936   };
3937   PyObject *result = 0 ;
3938
3939   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MessageElement_get",kwnames,&obj0,&obj1)) SWIG_fail;
3940   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message_element, 0 |  0 );
3941   if (!SWIG_IsOK(res1)) {
3942     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MessageElement_get" "', argument " "1"" of type '" "ldb_message_element *""'");
3943   }
3944   arg1 = (ldb_message_element *)(argp1);
3945   ecode2 = SWIG_AsVal_int(obj1, &val2);
3946   if (!SWIG_IsOK(ecode2)) {
3947     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MessageElement_get" "', argument " "2"" of type '" "int""'");
3948   }
3949   arg2 = (int)(val2);
3950   result = (PyObject *)ldb_message_element_get(arg1,arg2);
3951   resultobj = result;
3952   return resultobj;
3953 fail:
3954   return NULL;
3955 }
3956
3957
3958 SWIGINTERN PyObject *_wrap_delete_MessageElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3959   PyObject *resultobj = 0;
3960   ldb_message_element *arg1 = (ldb_message_element *) 0 ;
3961   void *argp1 = 0 ;
3962   int res1 = 0 ;
3963   PyObject *swig_obj[1] ;
3964
3965   if (!args) SWIG_fail;
3966   swig_obj[0] = args;
3967   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message_element, SWIG_POINTER_DISOWN |  0 );
3968   if (!SWIG_IsOK(res1)) {
3969     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MessageElement" "', argument " "1"" of type '" "ldb_message_element *""'");
3970   }
3971   arg1 = (ldb_message_element *)(argp1);
3972   delete_ldb_message_element(arg1);
3973   resultobj = SWIG_Py_Void();
3974   return resultobj;
3975 fail:
3976   return NULL;
3977 }
3978
3979
3980 SWIGINTERN PyObject *MessageElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3981   PyObject *obj;
3982   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3983   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message_element, SWIG_NewClientData(obj));
3984   return SWIG_Py_Void();
3985 }
3986
3987 SWIGINTERN PyObject *MessageElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3988   return SWIG_Python_InitShadowInstance(args);
3989 }
3990
3991 SWIGINTERN PyObject *_wrap_ldb_msg_list_elements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3992   PyObject *resultobj = 0;
3993   ldb_msg *arg1 = (ldb_msg *) 0 ;
3994   void *argp1 = 0 ;
3995   int res1 = 0 ;
3996   PyObject * obj0 = 0 ;
3997   char *  kwnames[] = {
3998     (char *) "msg", NULL
3999   };
4000   PyObject *result = 0 ;
4001
4002   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_msg_list_elements",kwnames,&obj0)) SWIG_fail;
4003   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4004   if (!SWIG_IsOK(res1)) {
4005     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_msg_list_elements" "', argument " "1"" of type '" "ldb_msg *""'");
4006   }
4007   arg1 = (ldb_msg *)(argp1);
4008   if (arg1 == NULL)
4009   SWIG_exception(SWIG_ValueError,
4010     "Message can not be None");
4011   result = (PyObject *)ldb_msg_list_elements(arg1);
4012   resultobj = result;
4013   return resultobj;
4014 fail:
4015   return NULL;
4016 }
4017
4018
4019 SWIGINTERN PyObject *_wrap_Message_dn_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4020   PyObject *resultobj = 0;
4021   ldb_msg *arg1 = (ldb_msg *) 0 ;
4022   ldb_dn *arg2 = (ldb_dn *) 0 ;
4023   void *argp1 = 0 ;
4024   int res1 = 0 ;
4025   void *argp2 = 0 ;
4026   int res2 = 0 ;
4027   PyObject *swig_obj[2] ;
4028
4029   if (!SWIG_Python_UnpackTuple(args,"Message_dn_set",2,2,swig_obj)) SWIG_fail;
4030   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4031   if (!SWIG_IsOK(res1)) {
4032     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_set" "', argument " "1"" of type '" "ldb_msg *""'");
4033   }
4034   arg1 = (ldb_msg *)(argp1);
4035   res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ldb_dn, SWIG_POINTER_DISOWN |  0 );
4036   if (!SWIG_IsOK(res2)) {
4037     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_dn_set" "', argument " "2"" of type '" "ldb_dn *""'");
4038   }
4039   arg2 = (ldb_dn *)(argp2);
4040   if (arg1 == NULL)
4041   SWIG_exception(SWIG_ValueError,
4042     "Message can not be None");
4043   if (arg1) (arg1)->dn = arg2;
4044   resultobj = SWIG_Py_Void();
4045   return resultobj;
4046 fail:
4047   return NULL;
4048 }
4049
4050
4051 SWIGINTERN PyObject *_wrap_Message_dn_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4052   PyObject *resultobj = 0;
4053   ldb_msg *arg1 = (ldb_msg *) 0 ;
4054   void *argp1 = 0 ;
4055   int res1 = 0 ;
4056   PyObject *swig_obj[1] ;
4057   ldb_dn *result = 0 ;
4058
4059   if (!args) SWIG_fail;
4060   swig_obj[0] = args;
4061   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4062   if (!SWIG_IsOK(res1)) {
4063     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_dn_get" "', argument " "1"" of type '" "ldb_msg *""'");
4064   }
4065   arg1 = (ldb_msg *)(argp1);
4066   if (arg1 == NULL)
4067   SWIG_exception(SWIG_ValueError,
4068     "Message can not be None");
4069   result = (ldb_dn *) ((arg1)->dn);
4070   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4071   return resultobj;
4072 fail:
4073   return NULL;
4074 }
4075
4076
4077 SWIGINTERN PyObject *_wrap_new_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4078   PyObject *resultobj = 0;
4079   ldb_dn *arg1 = (ldb_dn *) NULL ;
4080   void *argp1 = 0 ;
4081   int res1 = 0 ;
4082   PyObject * obj0 = 0 ;
4083   char *  kwnames[] = {
4084     (char *) "dn", NULL
4085   };
4086   ldb_msg *result = 0 ;
4087
4088   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_Message",kwnames,&obj0)) SWIG_fail;
4089   if (obj0) {
4090     res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_dn, 0 |  0 );
4091     if (!SWIG_IsOK(res1)) {
4092       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Message" "', argument " "1"" of type '" "ldb_dn *""'");
4093     }
4094     arg1 = (ldb_dn *)(argp1);
4095   }
4096   result = (ldb_msg *)new_ldb_msg(arg1);
4097   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_message, SWIG_POINTER_NEW |  0 );
4098   return resultobj;
4099 fail:
4100   return NULL;
4101 }
4102
4103
4104 SWIGINTERN PyObject *_wrap_delete_Message(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4105   PyObject *resultobj = 0;
4106   ldb_msg *arg1 = (ldb_msg *) 0 ;
4107   void *argp1 = 0 ;
4108   int res1 = 0 ;
4109   PyObject *swig_obj[1] ;
4110
4111   if (!args) SWIG_fail;
4112   swig_obj[0] = args;
4113   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, SWIG_POINTER_DISOWN |  0 );
4114   if (!SWIG_IsOK(res1)) {
4115     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Message" "', argument " "1"" of type '" "ldb_msg *""'");
4116   }
4117   arg1 = (ldb_msg *)(argp1);
4118   if (arg1 == NULL)
4119   SWIG_exception(SWIG_ValueError,
4120     "Message can not be None");
4121   delete_ldb_msg(arg1);
4122   resultobj = SWIG_Py_Void();
4123   return resultobj;
4124 fail:
4125   return NULL;
4126 }
4127
4128
4129 SWIGINTERN PyObject *_wrap_Message_find_element(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4130   PyObject *resultobj = 0;
4131   ldb_msg *arg1 = (ldb_msg *) 0 ;
4132   char *arg2 = (char *) 0 ;
4133   void *argp1 = 0 ;
4134   int res1 = 0 ;
4135   int res2 ;
4136   char *buf2 = 0 ;
4137   int alloc2 = 0 ;
4138   PyObject * obj0 = 0 ;
4139   PyObject * obj1 = 0 ;
4140   char *  kwnames[] = {
4141     (char *) "self",(char *) "name", NULL
4142   };
4143   ldb_message_element *result = 0 ;
4144
4145   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message_find_element",kwnames,&obj0,&obj1)) SWIG_fail;
4146   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4147   if (!SWIG_IsOK(res1)) {
4148     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_find_element" "', argument " "1"" of type '" "ldb_msg *""'");
4149   }
4150   arg1 = (ldb_msg *)(argp1);
4151   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4152   if (!SWIG_IsOK(res2)) {
4153     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message_find_element" "', argument " "2"" of type '" "char const *""'");
4154   }
4155   arg2 = (char *)(buf2);
4156   if (arg1 == NULL)
4157   SWIG_exception(SWIG_ValueError,
4158     "Message can not be None");
4159   result = (ldb_message_element *)ldb_msg_find_element(arg1,(char const *)arg2);
4160   {
4161     if (result == NULL)
4162     PyErr_SetString(PyExc_KeyError, "no such element");
4163     else
4164     resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_ldb_message_element, 0);
4165   }
4166   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4167   return resultobj;
4168 fail:
4169   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4170   return NULL;
4171 }
4172
4173
4174 SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4175   PyObject *resultobj = 0;
4176   ldb_msg *arg1 = (ldb_msg *) 0 ;
4177   char *arg2 = (char *) 0 ;
4178   ldb_message_element *arg3 = (ldb_message_element *) 0 ;
4179   void *argp1 = 0 ;
4180   int res1 = 0 ;
4181   int res2 ;
4182   char *buf2 = 0 ;
4183   int alloc2 = 0 ;
4184   void *argp3 = 0 ;
4185   int res3 = 0 ;
4186
4187   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
4188   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4189   if (!SWIG_IsOK(res1)) {
4190     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4191   }
4192   arg1 = (ldb_msg *)(argp1);
4193   res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
4194   if (!SWIG_IsOK(res2)) {
4195     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
4196   }
4197   arg2 = (char *)(buf2);
4198   res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_ldb_message_element, 0 |  0 );
4199   if (!SWIG_IsOK(res3)) {
4200     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Message___setitem__" "', argument " "3"" of type '" "ldb_message_element *""'");
4201   }
4202   arg3 = (ldb_message_element *)(argp3);
4203   if (arg1 == NULL)
4204   SWIG_exception(SWIG_ValueError,
4205     "Message can not be None");
4206   ldb_msg___setitem____SWIG_0(arg1,(char const *)arg2,arg3);
4207   resultobj = SWIG_Py_Void();
4208   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4209   return resultobj;
4210 fail:
4211   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4212   return NULL;
4213 }
4214
4215
4216 SWIGINTERN PyObject *_wrap_Message___setitem____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
4217   PyObject *resultobj = 0;
4218   ldb_msg *arg1 = (ldb_msg *) 0 ;
4219   char *arg2 = (char *) 0 ;
4220   PyObject *arg3 = (PyObject *) 0 ;
4221   void *argp1 = 0 ;
4222   int res1 = 0 ;
4223   int res2 ;
4224   char *buf2 = 0 ;
4225   int alloc2 = 0 ;
4226
4227   if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
4228   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4229   if (!SWIG_IsOK(res1)) {
4230     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___setitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4231   }
4232   arg1 = (ldb_msg *)(argp1);
4233   res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
4234   if (!SWIG_IsOK(res2)) {
4235     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___setitem__" "', argument " "2"" of type '" "char const *""'");
4236   }
4237   arg2 = (char *)(buf2);
4238   arg3 = swig_obj[2];
4239   if (arg1 == NULL)
4240   SWIG_exception(SWIG_ValueError,
4241     "Message can not be None");
4242   ldb_msg___setitem____SWIG_1(arg1,(char const *)arg2,arg3);
4243   resultobj = SWIG_Py_Void();
4244   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4245   return resultobj;
4246 fail:
4247   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4248   return NULL;
4249 }
4250
4251
4252 SWIGINTERN PyObject *_wrap_Message___setitem__(PyObject *self, PyObject *args) {
4253   int argc;
4254   PyObject *argv[4];
4255
4256   if (!(argc = SWIG_Python_UnpackTuple(args,"Message___setitem__",0,3,argv))) SWIG_fail;
4257   --argc;
4258   if (argc == 3) {
4259     int _v = 0;
4260     {
4261       void *vptr = 0;
4262       int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_ldb_message_element, 0);
4263       _v = SWIG_CheckState(res);
4264     }
4265     if (!_v) goto check_1;
4266     return _wrap_Message___setitem____SWIG_0(self, argc, argv);
4267   }
4268 check_1:
4269
4270   if (argc == 3) {
4271     return _wrap_Message___setitem____SWIG_1(self, argc, argv);
4272   }
4273
4274 fail:
4275   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'Message___setitem__'.\n"
4276     "  Possible C/C++ prototypes are:\n"
4277     "    __setitem__(ldb_msg *,char const *,ldb_message_element *)\n"
4278     "    __setitem__(ldb_msg *,char const *,PyObject *)\n");
4279   return NULL;
4280 }
4281
4282
4283 SWIGINTERN PyObject *_wrap_Message___len__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4284   PyObject *resultobj = 0;
4285   ldb_msg *arg1 = (ldb_msg *) 0 ;
4286   void *argp1 = 0 ;
4287   int res1 = 0 ;
4288   PyObject *swig_obj[1] ;
4289   unsigned int result;
4290
4291   if (!args) SWIG_fail;
4292   swig_obj[0] = args;
4293   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4294   if (!SWIG_IsOK(res1)) {
4295     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___len__" "', argument " "1"" of type '" "ldb_msg *""'");
4296   }
4297   arg1 = (ldb_msg *)(argp1);
4298   if (arg1 == NULL)
4299   SWIG_exception(SWIG_ValueError,
4300     "Message can not be None");
4301   result = (unsigned int)ldb_msg___len__(arg1);
4302   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4303   return resultobj;
4304 fail:
4305   return NULL;
4306 }
4307
4308
4309 SWIGINTERN PyObject *_wrap_Message_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4310   PyObject *resultobj = 0;
4311   ldb_msg *arg1 = (ldb_msg *) 0 ;
4312   void *argp1 = 0 ;
4313   int res1 = 0 ;
4314   PyObject *swig_obj[1] ;
4315   PyObject *result = 0 ;
4316
4317   if (!args) SWIG_fail;
4318   swig_obj[0] = args;
4319   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4320   if (!SWIG_IsOK(res1)) {
4321     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message_keys" "', argument " "1"" of type '" "ldb_msg *""'");
4322   }
4323   arg1 = (ldb_msg *)(argp1);
4324   if (arg1 == NULL)
4325   SWIG_exception(SWIG_ValueError,
4326     "Message can not be None");
4327   result = (PyObject *)ldb_msg_keys(arg1);
4328   resultobj = result;
4329   return resultobj;
4330 fail:
4331   return NULL;
4332 }
4333
4334
4335 SWIGINTERN PyObject *_wrap_Message___iter__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4336   PyObject *resultobj = 0;
4337   ldb_msg *arg1 = (ldb_msg *) 0 ;
4338   void *argp1 = 0 ;
4339   int res1 = 0 ;
4340   PyObject *swig_obj[1] ;
4341   PyObject *result = 0 ;
4342
4343   if (!args) SWIG_fail;
4344   swig_obj[0] = args;
4345   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4346   if (!SWIG_IsOK(res1)) {
4347     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___iter__" "', argument " "1"" of type '" "ldb_msg *""'");
4348   }
4349   arg1 = (ldb_msg *)(argp1);
4350   if (arg1 == NULL)
4351   SWIG_exception(SWIG_ValueError,
4352     "Message can not be None");
4353   result = (PyObject *)ldb_msg___iter__(arg1);
4354   resultobj = result;
4355   return resultobj;
4356 fail:
4357   return NULL;
4358 }
4359
4360
4361 SWIGINTERN PyObject *_wrap_Message___delitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4362   PyObject *resultobj = 0;
4363   ldb_msg *arg1 = (ldb_msg *) 0 ;
4364   char *arg2 = (char *) 0 ;
4365   void *argp1 = 0 ;
4366   int res1 = 0 ;
4367   int res2 ;
4368   char *buf2 = 0 ;
4369   int alloc2 = 0 ;
4370   PyObject * obj0 = 0 ;
4371   PyObject * obj1 = 0 ;
4372   char *  kwnames[] = {
4373     (char *) "self",(char *) "name", NULL
4374   };
4375
4376   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Message___delitem__",kwnames,&obj0,&obj1)) SWIG_fail;
4377   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_message, 0 |  0 );
4378   if (!SWIG_IsOK(res1)) {
4379     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Message___delitem__" "', argument " "1"" of type '" "ldb_msg *""'");
4380   }
4381   arg1 = (ldb_msg *)(argp1);
4382   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4383   if (!SWIG_IsOK(res2)) {
4384     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Message___delitem__" "', argument " "2"" of type '" "char const *""'");
4385   }
4386   arg2 = (char *)(buf2);
4387   if (arg1 == NULL)
4388   SWIG_exception(SWIG_ValueError,
4389     "Message can not be None");
4390   ldb_msg_remove_attr(arg1,(char const *)arg2);
4391   resultobj = SWIG_Py_Void();
4392   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4393   return resultobj;
4394 fail:
4395   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4396   return NULL;
4397 }
4398
4399
4400 SWIGINTERN PyObject *Message_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4401   PyObject *obj;
4402   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4403   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_message, SWIG_NewClientData(obj));
4404   return SWIG_Py_Void();
4405 }
4406
4407 SWIGINTERN PyObject *Message_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4408   return SWIG_Python_InitShadowInstance(args);
4409 }
4410
4411 SWIGINTERN PyObject *_wrap_ldb_ldif_to_pyobject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4412   PyObject *resultobj = 0;
4413   ldb_ldif *arg1 = (ldb_ldif *) 0 ;
4414   void *argp1 = 0 ;
4415   int res1 = 0 ;
4416   PyObject * obj0 = 0 ;
4417   char *  kwnames[] = {
4418     (char *) "ldif", NULL
4419   };
4420   PyObject *result = 0 ;
4421
4422   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ldb_ldif_to_pyobject",kwnames,&obj0)) SWIG_fail;
4423   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_ldif, 0 |  0 );
4424   if (!SWIG_IsOK(res1)) {
4425     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ldb_ldif_to_pyobject" "', argument " "1"" of type '" "ldb_ldif *""'");
4426   }
4427   arg1 = (ldb_ldif *)(argp1);
4428   result = (PyObject *)ldb_ldif_to_pyobject(arg1);
4429   resultobj = result;
4430   return resultobj;
4431 fail:
4432   return NULL;
4433 }
4434
4435
4436 SWIGINTERN PyObject *_wrap_new_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4437   PyObject *resultobj = 0;
4438   ldb *result = 0 ;
4439
4440   if (!SWIG_Python_UnpackTuple(args,"new_Ldb",0,0,0)) SWIG_fail;
4441   result = (ldb *)new_ldb();
4442   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_context, SWIG_POINTER_NEW |  0 );
4443   return resultobj;
4444 fail:
4445   return NULL;
4446 }
4447
4448
4449 SWIGINTERN PyObject *_wrap_Ldb_connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4450   PyObject *resultobj = 0;
4451   ldb *arg1 = (ldb *) 0 ;
4452   char *arg2 = (char *) 0 ;
4453   unsigned int arg3 = (unsigned int) 0 ;
4454   char **arg4 = (char **) (char **)NULL ;
4455   void *argp1 = 0 ;
4456   int res1 = 0 ;
4457   int res2 ;
4458   char *buf2 = 0 ;
4459   int alloc2 = 0 ;
4460   unsigned int val3 ;
4461   int ecode3 = 0 ;
4462   void *argp4 = 0 ;
4463   int res4 = 0 ;
4464   PyObject * obj0 = 0 ;
4465   PyObject * obj1 = 0 ;
4466   PyObject * obj2 = 0 ;
4467   PyObject * obj3 = 0 ;
4468   char *  kwnames[] = {
4469     (char *) "self",(char *) "url",(char *) "flags",(char *) "options", NULL
4470   };
4471   ldb_error result;
4472
4473   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Ldb_connect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4474   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4475   if (!SWIG_IsOK(res1)) {
4476     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_connect" "', argument " "1"" of type '" "ldb *""'");
4477   }
4478   arg1 = (ldb *)(argp1);
4479   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4480   if (!SWIG_IsOK(res2)) {
4481     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_connect" "', argument " "2"" of type '" "char const *""'");
4482   }
4483   arg2 = (char *)(buf2);
4484   if (obj2) {
4485     ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
4486     if (!SWIG_IsOK(ecode3)) {
4487       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_connect" "', argument " "3"" of type '" "unsigned int""'");
4488     }
4489     arg3 = (unsigned int)(val3);
4490   }
4491   if (obj3) {
4492     res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_char, 0 |  0 );
4493     if (!SWIG_IsOK(res4)) {
4494       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_connect" "', argument " "4"" of type '" "char const *[]""'");
4495     }
4496     arg4 = (char **)(argp4);
4497   }
4498   if (arg1 == NULL)
4499   SWIG_exception(SWIG_ValueError,
4500     "ldb context must be non-NULL");
4501   result = ldb_connect(arg1,(char const *)arg2,arg3,(char const *(*))arg4);
4502   if (result != 0) {
4503     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4504     SWIG_fail;
4505   }
4506   resultobj = Py_None;
4507   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4508   return resultobj;
4509 fail:
4510   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4511   return NULL;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_delete_Ldb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4516   PyObject *resultobj = 0;
4517   ldb *arg1 = (ldb *) 0 ;
4518   void *argp1 = 0 ;
4519   int res1 = 0 ;
4520   PyObject *swig_obj[1] ;
4521
4522   if (!args) SWIG_fail;
4523   swig_obj[0] = args;
4524   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, SWIG_POINTER_DISOWN |  0 );
4525   if (!SWIG_IsOK(res1)) {
4526     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Ldb" "', argument " "1"" of type '" "ldb *""'");
4527   }
4528   arg1 = (ldb *)(argp1);
4529   if (arg1 == NULL)
4530   SWIG_exception(SWIG_ValueError,
4531     "ldb context must be non-NULL");
4532   delete_ldb(arg1);
4533   resultobj = SWIG_Py_Void();
4534   return resultobj;
4535 fail:
4536   return NULL;
4537 }
4538
4539
4540 SWIGINTERN PyObject *_wrap_Ldb_search_ex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4541   PyObject *resultobj = 0;
4542   ldb *arg1 = (ldb *) 0 ;
4543   TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
4544   ldb_dn *arg3 = (ldb_dn *) NULL ;
4545   enum ldb_scope arg4 = (enum ldb_scope) LDB_SCOPE_DEFAULT ;
4546   char *arg5 = (char *) NULL ;
4547   char **arg6 = (char **) NULL ;
4548   struct ldb_control **arg7 = (struct ldb_control **) NULL ;
4549   struct ldb_result **arg8 = (struct ldb_result **) 0 ;
4550   void *argp1 = 0 ;
4551   int res1 = 0 ;
4552   int val4 ;
4553   int ecode4 = 0 ;
4554   int res5 ;
4555   char *buf5 = 0 ;
4556   int alloc5 = 0 ;
4557   void *argp7 = 0 ;
4558   int res7 = 0 ;
4559   struct ldb_result *temp_ldb_result8 ;
4560   int i8 ;
4561   PyObject * obj0 = 0 ;
4562   PyObject * obj1 = 0 ;
4563   PyObject * obj2 = 0 ;
4564   PyObject * obj3 = 0 ;
4565   PyObject * obj4 = 0 ;
4566   PyObject * obj5 = 0 ;
4567   char *  kwnames[] = {
4568     (char *) "self",(char *) "base",(char *) "scope",(char *) "expression",(char *) "attrs",(char *) "controls", NULL
4569   };
4570   ldb_error result;
4571
4572   arg2 = NULL;
4573   arg8 = &temp_ldb_result8;
4574   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:Ldb_search_ex",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
4575   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4576   if (!SWIG_IsOK(res1)) {
4577     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_search_ex" "', argument " "1"" of type '" "ldb *""'");
4578   }
4579   arg1 = (ldb *)(argp1);
4580   if (obj1) {
4581     if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg3) != 0) {
4582       SWIG_fail;
4583     }
4584   }
4585   if (obj2) {
4586     ecode4 = SWIG_AsVal_int(obj2, &val4);
4587     if (!SWIG_IsOK(ecode4)) {
4588       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Ldb_search_ex" "', argument " "4"" of type '" "enum ldb_scope""'");
4589     }
4590     arg4 = (enum ldb_scope)(val4);
4591   }
4592   if (obj3) {
4593     res5 = SWIG_AsCharPtrAndSize(obj3, &buf5, NULL, &alloc5);
4594     if (!SWIG_IsOK(res5)) {
4595       SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Ldb_search_ex" "', argument " "5"" of type '" "char const *""'");
4596     }
4597     arg5 = (char *)(buf5);
4598   }
4599   if (obj4) {
4600     if (obj4 == Py_None) {
4601       arg6 = NULL;
4602     } else if (PySequence_Check(obj4)) {
4603       int i;
4604       arg6 = talloc_array(NULL, char *, PySequence_Size(obj4)+1);
4605       for(i = 0; i < PySequence_Size(obj4); i++)
4606       arg6[i] = PyString_AsString(PySequence_GetItem(obj4, i));
4607       arg6[i] = NULL;
4608     } else {
4609       SWIG_exception(SWIG_TypeError, "expected sequence");
4610     }
4611   }
4612   if (obj5) {
4613     res7 = SWIG_ConvertPtr(obj5, &argp7,SWIGTYPE_p_p_ldb_control, 0 |  0 );
4614     if (!SWIG_IsOK(res7)) {
4615       SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Ldb_search_ex" "', argument " "7"" of type '" "struct ldb_control **""'");
4616     }
4617     arg7 = (struct ldb_control **)(argp7);
4618   }
4619   if (arg1 == NULL)
4620   SWIG_exception(SWIG_ValueError,
4621     "ldb context must be non-NULL");
4622   result = ldb_search_ex(arg1,arg2,arg3,arg4,(char const *)arg5,(char const *const *)arg6,arg7,arg8);
4623   if (result != 0) {
4624     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4625     SWIG_fail;
4626   }
4627   resultobj = Py_None;
4628   resultobj = PyList_New((*arg8)->count);
4629   for (i8 = 0; i8 < (*arg8)->count; i8++) {
4630     PyList_SetItem(resultobj, i8,
4631       SWIG_NewPointerObj((*arg8)->msgs[i8], SWIGTYPE_p_ldb_message, 0)
4632       );
4633   }
4634   talloc_free(arg3);
4635   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
4636   talloc_free(arg6);
4637   return resultobj;
4638 fail:
4639   talloc_free(arg3);
4640   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
4641   talloc_free(arg6);
4642   return NULL;
4643 }
4644
4645
4646 SWIGINTERN PyObject *_wrap_Ldb_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4647   PyObject *resultobj = 0;
4648   ldb *arg1 = (ldb *) 0 ;
4649   ldb_dn *arg2 = (ldb_dn *) 0 ;
4650   void *argp1 = 0 ;
4651   int res1 = 0 ;
4652   PyObject * obj0 = 0 ;
4653   PyObject * obj1 = 0 ;
4654   char *  kwnames[] = {
4655     (char *) "self",(char *) "dn", NULL
4656   };
4657   ldb_error result;
4658
4659   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_delete",kwnames,&obj0,&obj1)) SWIG_fail;
4660   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4661   if (!SWIG_IsOK(res1)) {
4662     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_delete" "', argument " "1"" of type '" "ldb *""'");
4663   }
4664   arg1 = (ldb *)(argp1);
4665   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
4666     SWIG_fail;
4667   }
4668   if (arg1 == NULL)
4669   SWIG_exception(SWIG_ValueError,
4670     "ldb context must be non-NULL");
4671   result = ldb_delete(arg1,arg2);
4672   if (result != 0) {
4673     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4674     SWIG_fail;
4675   }
4676   resultobj = Py_None;
4677   talloc_free(arg2);
4678   return resultobj;
4679 fail:
4680   talloc_free(arg2);
4681   return NULL;
4682 }
4683
4684
4685 SWIGINTERN PyObject *_wrap_Ldb_rename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4686   PyObject *resultobj = 0;
4687   ldb *arg1 = (ldb *) 0 ;
4688   ldb_dn *arg2 = (ldb_dn *) 0 ;
4689   ldb_dn *arg3 = (ldb_dn *) 0 ;
4690   void *argp1 = 0 ;
4691   int res1 = 0 ;
4692   PyObject * obj0 = 0 ;
4693   PyObject * obj1 = 0 ;
4694   PyObject * obj2 = 0 ;
4695   char *  kwnames[] = {
4696     (char *) "self",(char *) "olddn",(char *) "newdn", NULL
4697   };
4698   ldb_error result;
4699
4700   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_rename",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4701   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4702   if (!SWIG_IsOK(res1)) {
4703     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_rename" "', argument " "1"" of type '" "ldb *""'");
4704   }
4705   arg1 = (ldb *)(argp1);
4706   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
4707     SWIG_fail;
4708   }
4709   if (ldb_dn_from_pyobject(NULL, obj2, arg1, &arg3) != 0) {
4710     SWIG_fail;
4711   }
4712   if (arg1 == NULL)
4713   SWIG_exception(SWIG_ValueError,
4714     "ldb context must be non-NULL");
4715   result = ldb_rename(arg1,arg2,arg3);
4716   if (result != 0) {
4717     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4718     SWIG_fail;
4719   }
4720   resultobj = Py_None;
4721   talloc_free(arg2);
4722   talloc_free(arg3);
4723   return resultobj;
4724 fail:
4725   talloc_free(arg2);
4726   talloc_free(arg3);
4727   return NULL;
4728 }
4729
4730
4731 SWIGINTERN PyObject *_wrap_Ldb_parse_control_strings(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4732   PyObject *resultobj = 0;
4733   ldb *arg1 = (ldb *) 0 ;
4734   TALLOC_CTX *arg2 = (TALLOC_CTX *) 0 ;
4735   char **arg3 = (char **) 0 ;
4736   void *argp1 = 0 ;
4737   int res1 = 0 ;
4738   PyObject * obj0 = 0 ;
4739   PyObject * obj1 = 0 ;
4740   char *  kwnames[] = {
4741     (char *) "self",(char *) "control_strings", NULL
4742   };
4743   struct ldb_control **result = 0 ;
4744
4745   arg2 = NULL;
4746   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_control_strings",kwnames,&obj0,&obj1)) SWIG_fail;
4747   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4748   if (!SWIG_IsOK(res1)) {
4749     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_control_strings" "', argument " "1"" of type '" "ldb *""'");
4750   }
4751   arg1 = (ldb *)(argp1);
4752   if (obj1 == Py_None) {
4753     arg3 = NULL;
4754   } else if (PySequence_Check(obj1)) {
4755     int i;
4756     arg3 = talloc_array(NULL, char *, PySequence_Size(obj1)+1);
4757     for(i = 0; i < PySequence_Size(obj1); i++)
4758     arg3[i] = PyString_AsString(PySequence_GetItem(obj1, i));
4759     arg3[i] = NULL;
4760   } else {
4761     SWIG_exception(SWIG_TypeError, "expected sequence");
4762   }
4763   if (arg1 == NULL)
4764   SWIG_exception(SWIG_ValueError,
4765     "ldb context must be non-NULL");
4766   result = (struct ldb_control **)ldb_parse_control_strings(arg1,arg2,(char const *const *)arg3);
4767   if (result == NULL) {
4768     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(s)", ldb_errstring(arg1)));
4769     SWIG_fail;
4770   }
4771   resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_p_ldb_control, 0);
4772   talloc_free(arg3);
4773   return resultobj;
4774 fail:
4775   talloc_free(arg3);
4776   return NULL;
4777 }
4778
4779
4780 SWIGINTERN PyObject *_wrap_Ldb_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4781   PyObject *resultobj = 0;
4782   ldb *arg1 = (ldb *) 0 ;
4783   ldb_msg *arg2 = (ldb_msg *) 0 ;
4784   void *argp1 = 0 ;
4785   int res1 = 0 ;
4786   PyObject * obj0 = 0 ;
4787   PyObject * obj1 = 0 ;
4788   char *  kwnames[] = {
4789     (char *) "self",(char *) "add_msg", NULL
4790   };
4791   ldb_error result;
4792
4793   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_add",kwnames,&obj0,&obj1)) SWIG_fail;
4794   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4795   if (!SWIG_IsOK(res1)) {
4796     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_add" "', argument " "1"" of type '" "ldb *""'");
4797   }
4798   arg1 = (ldb *)(argp1);
4799   {
4800     Py_ssize_t dict_pos, msg_pos;
4801     ldb_message_element *msgel;
4802     PyObject *key, *value;
4803
4804     if (PyDict_Check(obj1)) {
4805       PyObject *dn_value = PyDict_GetItemString(obj1, "dn");
4806       arg2 = ldb_msg_new(NULL);
4807       arg2->elements = talloc_zero_array(arg2, struct ldb_message_element, PyDict_Size(obj1));
4808       msg_pos = dict_pos = 0;
4809       if (dn_value) {
4810         /* using argp1 (magic SWIG value) here is a hack */
4811         if (ldb_dn_from_pyobject(arg2, dn_value, argp1, &arg2->dn) != 0) {
4812           SWIG_exception(SWIG_TypeError, "unable to import dn object");
4813         }
4814         if (arg2->dn == NULL) {
4815           SWIG_exception(SWIG_TypeError, "dn set but not found");
4816         }
4817       }
4818
4819       while (PyDict_Next(obj1, &dict_pos, &key, &value)) {
4820         char *key_str = PyString_AsString(key);
4821         if (strcmp(key_str, "dn") != 0) {
4822           msgel = ldb_msg_element_from_pyobject(arg2->elements, value, 0, key_str);
4823           if (msgel == NULL) {
4824             SWIG_exception(SWIG_TypeError, "unable to import element");
4825           }
4826           memcpy(&arg2->elements[msg_pos], msgel, sizeof(*msgel));
4827           msg_pos++;
4828         }
4829       }
4830
4831       if (arg2->dn == NULL) {
4832         SWIG_exception(SWIG_TypeError, "no dn set");
4833       }
4834
4835       arg2->num_elements = msg_pos;
4836     } else {
4837       if (SWIG_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_ldb_message, 0) != 0) {
4838         SWIG_exception(SWIG_TypeError, "unable to convert ldb message");
4839       }
4840     }
4841   }
4842   if (arg1 == NULL)
4843   SWIG_exception(SWIG_ValueError,
4844     "ldb context must be non-NULL");
4845   if (arg2 == NULL)
4846   SWIG_exception(SWIG_ValueError,
4847     "Message can not be None");
4848   result = ldb_add(arg1,arg2);
4849   if (result != 0) {
4850     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4851     SWIG_fail;
4852   }
4853   resultobj = Py_None;
4854   return resultobj;
4855 fail:
4856   return NULL;
4857 }
4858
4859
4860 SWIGINTERN PyObject *_wrap_Ldb_modify(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4861   PyObject *resultobj = 0;
4862   ldb *arg1 = (ldb *) 0 ;
4863   ldb_msg *arg2 = (ldb_msg *) 0 ;
4864   void *argp1 = 0 ;
4865   int res1 = 0 ;
4866   void *argp2 = 0 ;
4867   int res2 = 0 ;
4868   PyObject * obj0 = 0 ;
4869   PyObject * obj1 = 0 ;
4870   char *  kwnames[] = {
4871     (char *) "self",(char *) "message", NULL
4872   };
4873   ldb_error result;
4874
4875   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_modify",kwnames,&obj0,&obj1)) SWIG_fail;
4876   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4877   if (!SWIG_IsOK(res1)) {
4878     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_modify" "', argument " "1"" of type '" "ldb *""'");
4879   }
4880   arg1 = (ldb *)(argp1);
4881   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_ldb_message, 0 |  0 );
4882   if (!SWIG_IsOK(res2)) {
4883     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_modify" "', argument " "2"" of type '" "ldb_msg *""'");
4884   }
4885   arg2 = (ldb_msg *)(argp2);
4886   if (arg1 == NULL)
4887   SWIG_exception(SWIG_ValueError,
4888     "ldb context must be non-NULL");
4889   if (arg2 == NULL)
4890   SWIG_exception(SWIG_ValueError,
4891     "Message can not be None");
4892   result = ldb_modify(arg1,arg2);
4893   if (result != 0) {
4894     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
4895     SWIG_fail;
4896   }
4897   resultobj = Py_None;
4898   return resultobj;
4899 fail:
4900   return NULL;
4901 }
4902
4903
4904 SWIGINTERN PyObject *_wrap_Ldb_get_config_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4905   PyObject *resultobj = 0;
4906   ldb *arg1 = (ldb *) 0 ;
4907   void *argp1 = 0 ;
4908   int res1 = 0 ;
4909   PyObject *swig_obj[1] ;
4910   ldb_dn *result = 0 ;
4911
4912   if (!args) SWIG_fail;
4913   swig_obj[0] = args;
4914   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4915   if (!SWIG_IsOK(res1)) {
4916     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_config_basedn" "', argument " "1"" of type '" "ldb *""'");
4917   }
4918   arg1 = (ldb *)(argp1);
4919   if (arg1 == NULL)
4920   SWIG_exception(SWIG_ValueError,
4921     "ldb context must be non-NULL");
4922   result = (ldb_dn *)ldb_get_config_basedn(arg1);
4923   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4924   return resultobj;
4925 fail:
4926   return NULL;
4927 }
4928
4929
4930 SWIGINTERN PyObject *_wrap_Ldb_get_root_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4931   PyObject *resultobj = 0;
4932   ldb *arg1 = (ldb *) 0 ;
4933   void *argp1 = 0 ;
4934   int res1 = 0 ;
4935   PyObject *swig_obj[1] ;
4936   ldb_dn *result = 0 ;
4937
4938   if (!args) SWIG_fail;
4939   swig_obj[0] = args;
4940   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4941   if (!SWIG_IsOK(res1)) {
4942     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_root_basedn" "', argument " "1"" of type '" "ldb *""'");
4943   }
4944   arg1 = (ldb *)(argp1);
4945   if (arg1 == NULL)
4946   SWIG_exception(SWIG_ValueError,
4947     "ldb context must be non-NULL");
4948   result = (ldb_dn *)ldb_get_root_basedn(arg1);
4949   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4950   return resultobj;
4951 fail:
4952   return NULL;
4953 }
4954
4955
4956 SWIGINTERN PyObject *_wrap_Ldb_get_schema_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4957   PyObject *resultobj = 0;
4958   ldb *arg1 = (ldb *) 0 ;
4959   void *argp1 = 0 ;
4960   int res1 = 0 ;
4961   PyObject *swig_obj[1] ;
4962   ldb_dn *result = 0 ;
4963
4964   if (!args) SWIG_fail;
4965   swig_obj[0] = args;
4966   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4967   if (!SWIG_IsOK(res1)) {
4968     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_schema_basedn" "', argument " "1"" of type '" "ldb *""'");
4969   }
4970   arg1 = (ldb *)(argp1);
4971   if (arg1 == NULL)
4972   SWIG_exception(SWIG_ValueError,
4973     "ldb context must be non-NULL");
4974   result = (ldb_dn *)ldb_get_schema_basedn(arg1);
4975   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
4976   return resultobj;
4977 fail:
4978   return NULL;
4979 }
4980
4981
4982 SWIGINTERN PyObject *_wrap_Ldb_get_default_basedn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4983   PyObject *resultobj = 0;
4984   ldb *arg1 = (ldb *) 0 ;
4985   void *argp1 = 0 ;
4986   int res1 = 0 ;
4987   PyObject *swig_obj[1] ;
4988   ldb_dn *result = 0 ;
4989
4990   if (!args) SWIG_fail;
4991   swig_obj[0] = args;
4992   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
4993   if (!SWIG_IsOK(res1)) {
4994     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_default_basedn" "', argument " "1"" of type '" "ldb *""'");
4995   }
4996   arg1 = (ldb *)(argp1);
4997   if (arg1 == NULL)
4998   SWIG_exception(SWIG_ValueError,
4999     "ldb context must be non-NULL");
5000   result = (ldb_dn *)ldb_get_default_basedn(arg1);
5001   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ldb_dn, 0 |  0 );
5002   return resultobj;
5003 fail:
5004   return NULL;
5005 }
5006
5007
5008 SWIGINTERN PyObject *_wrap_Ldb_schema_format_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5009   PyObject *resultobj = 0;
5010   ldb *arg1 = (ldb *) 0 ;
5011   char *arg2 = (char *) 0 ;
5012   PyObject *arg3 = (PyObject *) 0 ;
5013   void *argp1 = 0 ;
5014   int res1 = 0 ;
5015   int res2 ;
5016   char *buf2 = 0 ;
5017   int alloc2 = 0 ;
5018   PyObject * obj0 = 0 ;
5019   PyObject * obj1 = 0 ;
5020   PyObject * obj2 = 0 ;
5021   char *  kwnames[] = {
5022     (char *) "self",(char *) "element_name",(char *) "val", NULL
5023   };
5024   PyObject *result = 0 ;
5025
5026   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_schema_format_value",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5027   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5028   if (!SWIG_IsOK(res1)) {
5029     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_format_value" "', argument " "1"" of type '" "ldb *""'");
5030   }
5031   arg1 = (ldb *)(argp1);
5032   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5033   if (!SWIG_IsOK(res2)) {
5034     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_format_value" "', argument " "2"" of type '" "char const *""'");
5035   }
5036   arg2 = (char *)(buf2);
5037   arg3 = obj2;
5038   if (arg1 == NULL)
5039   SWIG_exception(SWIG_ValueError,
5040     "ldb context must be non-NULL");
5041   result = (PyObject *)ldb_schema_format_value(arg1,(char const *)arg2,arg3);
5042   resultobj = result;
5043   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5044   return resultobj;
5045 fail:
5046   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5047   return NULL;
5048 }
5049
5050
5051 SWIGINTERN PyObject *_wrap_Ldb_errstring(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5052   PyObject *resultobj = 0;
5053   ldb *arg1 = (ldb *) 0 ;
5054   void *argp1 = 0 ;
5055   int res1 = 0 ;
5056   PyObject *swig_obj[1] ;
5057   char *result = 0 ;
5058
5059   if (!args) SWIG_fail;
5060   swig_obj[0] = args;
5061   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5062   if (!SWIG_IsOK(res1)) {
5063     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_errstring" "', argument " "1"" of type '" "ldb *""'");
5064   }
5065   arg1 = (ldb *)(argp1);
5066   if (arg1 == NULL)
5067   SWIG_exception(SWIG_ValueError,
5068     "ldb context must be non-NULL");
5069   result = (char *)ldb_errstring(arg1);
5070   resultobj = SWIG_FromCharPtr((const char *)result);
5071   return resultobj;
5072 fail:
5073   return NULL;
5074 }
5075
5076
5077 SWIGINTERN PyObject *_wrap_Ldb_set_create_perms(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5078   PyObject *resultobj = 0;
5079   ldb *arg1 = (ldb *) 0 ;
5080   unsigned int arg2 ;
5081   void *argp1 = 0 ;
5082   int res1 = 0 ;
5083   unsigned int val2 ;
5084   int ecode2 = 0 ;
5085   PyObject * obj0 = 0 ;
5086   PyObject * obj1 = 0 ;
5087   char *  kwnames[] = {
5088     (char *) "self",(char *) "perms", NULL
5089   };
5090
5091   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_create_perms",kwnames,&obj0,&obj1)) SWIG_fail;
5092   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5093   if (!SWIG_IsOK(res1)) {
5094     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_create_perms" "', argument " "1"" of type '" "ldb *""'");
5095   }
5096   arg1 = (ldb *)(argp1);
5097   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5098   if (!SWIG_IsOK(ecode2)) {
5099     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Ldb_set_create_perms" "', argument " "2"" of type '" "unsigned int""'");
5100   }
5101   arg2 = (unsigned int)(val2);
5102   if (arg1 == NULL)
5103   SWIG_exception(SWIG_ValueError,
5104     "ldb context must be non-NULL");
5105   ldb_set_create_perms(arg1,arg2);
5106   resultobj = SWIG_Py_Void();
5107   return resultobj;
5108 fail:
5109   return NULL;
5110 }
5111
5112
5113 SWIGINTERN PyObject *_wrap_Ldb_set_modules_dir(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5114   PyObject *resultobj = 0;
5115   ldb *arg1 = (ldb *) 0 ;
5116   char *arg2 = (char *) 0 ;
5117   void *argp1 = 0 ;
5118   int res1 = 0 ;
5119   int res2 ;
5120   char *buf2 = 0 ;
5121   int alloc2 = 0 ;
5122   PyObject * obj0 = 0 ;
5123   PyObject * obj1 = 0 ;
5124   char *  kwnames[] = {
5125     (char *) "self",(char *) "path", NULL
5126   };
5127
5128   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_modules_dir",kwnames,&obj0,&obj1)) SWIG_fail;
5129   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5130   if (!SWIG_IsOK(res1)) {
5131     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_modules_dir" "', argument " "1"" of type '" "ldb *""'");
5132   }
5133   arg1 = (ldb *)(argp1);
5134   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5135   if (!SWIG_IsOK(res2)) {
5136     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_modules_dir" "', argument " "2"" of type '" "char const *""'");
5137   }
5138   arg2 = (char *)(buf2);
5139   if (arg1 == NULL)
5140   SWIG_exception(SWIG_ValueError,
5141     "ldb context must be non-NULL");
5142   ldb_set_modules_dir(arg1,(char const *)arg2);
5143   resultobj = SWIG_Py_Void();
5144   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5145   return resultobj;
5146 fail:
5147   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5148   return NULL;
5149 }
5150
5151
5152 SWIGINTERN PyObject *_wrap_Ldb_set_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5153   PyObject *resultobj = 0;
5154   ldb *arg1 = (ldb *) 0 ;
5155   void (*arg2)(void *,enum ldb_debug_level,char const *,va_list) = (void (*)(void *,enum ldb_debug_level,char const *,va_list)) 0 ;
5156   void *arg3 = (void *) 0 ;
5157   void *argp1 = 0 ;
5158   int res1 = 0 ;
5159   PyObject * obj0 = 0 ;
5160   PyObject * obj1 = 0 ;
5161   char *  kwnames[] = {
5162     (char *) "self",(char *) "debug", NULL
5163   };
5164   ldb_error result;
5165
5166   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_set_debug",kwnames,&obj0,&obj1)) SWIG_fail;
5167   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5168   if (!SWIG_IsOK(res1)) {
5169     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_debug" "', argument " "1"" of type '" "ldb *""'");
5170   }
5171   arg1 = (ldb *)(argp1);
5172   arg2 = py_ldb_debug;
5173   /* FIXME: Should be decreased somewhere as well. Perhaps register a
5174          destructor and tie it to the ldb context ? */
5175   Py_INCREF(obj1);
5176   arg3 = obj1;
5177   if (arg1 == NULL)
5178   SWIG_exception(SWIG_ValueError,
5179     "ldb context must be non-NULL");
5180   result = ldb_set_debug(arg1,arg2,arg3);
5181   if (result != 0) {
5182     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5183     SWIG_fail;
5184   }
5185   resultobj = Py_None;
5186   return resultobj;
5187 fail:
5188   return NULL;
5189 }
5190
5191
5192 SWIGINTERN PyObject *_wrap_Ldb_set_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5193   PyObject *resultobj = 0;
5194   ldb *arg1 = (ldb *) 0 ;
5195   char *arg2 = (char *) 0 ;
5196   void *arg3 = (void *) 0 ;
5197   void *argp1 = 0 ;
5198   int res1 = 0 ;
5199   int res2 ;
5200   char *buf2 = 0 ;
5201   int alloc2 = 0 ;
5202   int res3 ;
5203   PyObject * obj0 = 0 ;
5204   PyObject * obj1 = 0 ;
5205   PyObject * obj2 = 0 ;
5206   char *  kwnames[] = {
5207     (char *) "self",(char *) "name",(char *) "value", NULL
5208   };
5209   ldb_error result;
5210
5211   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Ldb_set_opaque",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5212   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5213   if (!SWIG_IsOK(res1)) {
5214     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_set_opaque" "', argument " "1"" of type '" "ldb *""'");
5215   }
5216   arg1 = (ldb *)(argp1);
5217   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5218   if (!SWIG_IsOK(res2)) {
5219     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_set_opaque" "', argument " "2"" of type '" "char const *""'");
5220   }
5221   arg2 = (char *)(buf2);
5222   res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
5223   if (!SWIG_IsOK(res3)) {
5224     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Ldb_set_opaque" "', argument " "3"" of type '" "void *""'");
5225   }
5226   if (arg1 == NULL)
5227   SWIG_exception(SWIG_ValueError,
5228     "ldb context must be non-NULL");
5229   result = ldb_set_opaque(arg1,(char const *)arg2,arg3);
5230   if (result != 0) {
5231     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5232     SWIG_fail;
5233   }
5234   resultobj = Py_None;
5235   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5236   return resultobj;
5237 fail:
5238   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5239   return NULL;
5240 }
5241
5242
5243 SWIGINTERN PyObject *_wrap_Ldb_get_opaque(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5244   PyObject *resultobj = 0;
5245   ldb *arg1 = (ldb *) 0 ;
5246   char *arg2 = (char *) 0 ;
5247   void *argp1 = 0 ;
5248   int res1 = 0 ;
5249   int res2 ;
5250   char *buf2 = 0 ;
5251   int alloc2 = 0 ;
5252   PyObject * obj0 = 0 ;
5253   PyObject * obj1 = 0 ;
5254   char *  kwnames[] = {
5255     (char *) "self",(char *) "name", NULL
5256   };
5257   void *result = 0 ;
5258
5259   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_get_opaque",kwnames,&obj0,&obj1)) SWIG_fail;
5260   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5261   if (!SWIG_IsOK(res1)) {
5262     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_get_opaque" "', argument " "1"" of type '" "ldb *""'");
5263   }
5264   arg1 = (ldb *)(argp1);
5265   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5266   if (!SWIG_IsOK(res2)) {
5267     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_get_opaque" "', argument " "2"" of type '" "char const *""'");
5268   }
5269   arg2 = (char *)(buf2);
5270   if (arg1 == NULL)
5271   SWIG_exception(SWIG_ValueError,
5272     "ldb context must be non-NULL");
5273   result = (void *)ldb_get_opaque(arg1,(char const *)arg2);
5274   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
5275   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5276   return resultobj;
5277 fail:
5278   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5279   return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_Ldb_transaction_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5284   PyObject *resultobj = 0;
5285   ldb *arg1 = (ldb *) 0 ;
5286   void *argp1 = 0 ;
5287   int res1 = 0 ;
5288   PyObject *swig_obj[1] ;
5289   ldb_error result;
5290
5291   if (!args) SWIG_fail;
5292   swig_obj[0] = args;
5293   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5294   if (!SWIG_IsOK(res1)) {
5295     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_start" "', argument " "1"" of type '" "ldb *""'");
5296   }
5297   arg1 = (ldb *)(argp1);
5298   if (arg1 == NULL)
5299   SWIG_exception(SWIG_ValueError,
5300     "ldb context must be non-NULL");
5301   result = ldb_transaction_start(arg1);
5302   if (result != 0) {
5303     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5304     SWIG_fail;
5305   }
5306   resultobj = Py_None;
5307   return resultobj;
5308 fail:
5309   return NULL;
5310 }
5311
5312
5313 SWIGINTERN PyObject *_wrap_Ldb_transaction_commit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5314   PyObject *resultobj = 0;
5315   ldb *arg1 = (ldb *) 0 ;
5316   void *argp1 = 0 ;
5317   int res1 = 0 ;
5318   PyObject *swig_obj[1] ;
5319   ldb_error result;
5320
5321   if (!args) SWIG_fail;
5322   swig_obj[0] = args;
5323   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5324   if (!SWIG_IsOK(res1)) {
5325     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_transaction_commit" "', argument " "1"" of type '" "ldb *""'");
5326   }
5327   arg1 = (ldb *)(argp1);
5328   if (arg1 == NULL)
5329   SWIG_exception(SWIG_ValueError,
5330     "ldb context must be non-NULL");
5331   result = ldb_transaction_commit(arg1);
5332   if (result != 0) {
5333     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5334     SWIG_fail;
5335   }
5336   resultobj = Py_None;
5337   return resultobj;
5338 fail:
5339   return NULL;
5340 }
5341
5342
5343 SWIGINTERN PyObject *_wrap_Ldb_transaction_cancel(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_error result;
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_transaction_cancel" "', 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_transaction_cancel(arg1);
5362   if (result != 0) {
5363     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5364     SWIG_fail;
5365   }
5366   resultobj = Py_None;
5367   return resultobj;
5368 fail:
5369   return NULL;
5370 }
5371
5372
5373 SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5374   PyObject *resultobj = 0;
5375   ldb *arg1 = (ldb *) 0 ;
5376   char *arg2 = (char *) 0 ;
5377   void *argp1 = 0 ;
5378   int res1 = 0 ;
5379   int res2 ;
5380   char *buf2 = 0 ;
5381   int alloc2 = 0 ;
5382   PyObject * obj0 = 0 ;
5383   PyObject * obj1 = 0 ;
5384   char *  kwnames[] = {
5385     (char *) "self",(char *) "name", NULL
5386   };
5387
5388   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_schema_attribute_remove",kwnames,&obj0,&obj1)) SWIG_fail;
5389   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5390   if (!SWIG_IsOK(res1)) {
5391     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_remove" "', argument " "1"" of type '" "ldb *""'");
5392   }
5393   arg1 = (ldb *)(argp1);
5394   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5395   if (!SWIG_IsOK(res2)) {
5396     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_remove" "', argument " "2"" of type '" "char const *""'");
5397   }
5398   arg2 = (char *)(buf2);
5399   if (arg1 == NULL)
5400   SWIG_exception(SWIG_ValueError,
5401     "ldb context must be non-NULL");
5402   ldb_schema_attribute_remove(arg1,(char const *)arg2);
5403   resultobj = SWIG_Py_Void();
5404   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5405   return resultobj;
5406 fail:
5407   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5408   return NULL;
5409 }
5410
5411
5412 SWIGINTERN PyObject *_wrap_Ldb_schema_attribute_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5413   PyObject *resultobj = 0;
5414   ldb *arg1 = (ldb *) 0 ;
5415   char *arg2 = (char *) 0 ;
5416   unsigned int arg3 ;
5417   char *arg4 = (char *) 0 ;
5418   void *argp1 = 0 ;
5419   int res1 = 0 ;
5420   int res2 ;
5421   char *buf2 = 0 ;
5422   int alloc2 = 0 ;
5423   unsigned int val3 ;
5424   int ecode3 = 0 ;
5425   int res4 ;
5426   char *buf4 = 0 ;
5427   int alloc4 = 0 ;
5428   PyObject * obj0 = 0 ;
5429   PyObject * obj1 = 0 ;
5430   PyObject * obj2 = 0 ;
5431   PyObject * obj3 = 0 ;
5432   char *  kwnames[] = {
5433     (char *) "self",(char *) "attribute",(char *) "flags",(char *) "syntax", NULL
5434   };
5435   ldb_error result;
5436
5437   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Ldb_schema_attribute_add",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5438   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5439   if (!SWIG_IsOK(res1)) {
5440     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_schema_attribute_add" "', argument " "1"" of type '" "ldb *""'");
5441   }
5442   arg1 = (ldb *)(argp1);
5443   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5444   if (!SWIG_IsOK(res2)) {
5445     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_schema_attribute_add" "', argument " "2"" of type '" "char const *""'");
5446   }
5447   arg2 = (char *)(buf2);
5448   ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
5449   if (!SWIG_IsOK(ecode3)) {
5450     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Ldb_schema_attribute_add" "', argument " "3"" of type '" "unsigned int""'");
5451   }
5452   arg3 = (unsigned int)(val3);
5453   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
5454   if (!SWIG_IsOK(res4)) {
5455     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Ldb_schema_attribute_add" "', argument " "4"" of type '" "char const *""'");
5456   }
5457   arg4 = (char *)(buf4);
5458   if (arg1 == NULL)
5459   SWIG_exception(SWIG_ValueError,
5460     "ldb context must be non-NULL");
5461   result = ldb_schema_attribute_add(arg1,(char const *)arg2,arg3,(char const *)arg4);
5462   if (result != 0) {
5463     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5464     SWIG_fail;
5465   }
5466   resultobj = Py_None;
5467   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5468   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5469   return resultobj;
5470 fail:
5471   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5472   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
5473   return NULL;
5474 }
5475
5476
5477 SWIGINTERN PyObject *_wrap_Ldb_setup_wellknown_attributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5478   PyObject *resultobj = 0;
5479   ldb *arg1 = (ldb *) 0 ;
5480   void *argp1 = 0 ;
5481   int res1 = 0 ;
5482   PyObject *swig_obj[1] ;
5483   ldb_error result;
5484
5485   if (!args) SWIG_fail;
5486   swig_obj[0] = args;
5487   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5488   if (!SWIG_IsOK(res1)) {
5489     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_setup_wellknown_attributes" "', argument " "1"" of type '" "ldb *""'");
5490   }
5491   arg1 = (ldb *)(argp1);
5492   if (arg1 == NULL)
5493   SWIG_exception(SWIG_ValueError,
5494     "ldb context must be non-NULL");
5495   result = ldb_setup_wellknown_attributes(arg1);
5496   if (result != 0) {
5497     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5498     SWIG_fail;
5499   }
5500   resultobj = Py_None;
5501   return resultobj;
5502 fail:
5503   return NULL;
5504 }
5505
5506
5507 SWIGINTERN PyObject *_wrap_Ldb___contains__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5508   PyObject *resultobj = 0;
5509   ldb *arg1 = (ldb *) 0 ;
5510   ldb_dn *arg2 = (ldb_dn *) 0 ;
5511   struct ldb_result **arg3 = (struct ldb_result **) 0 ;
5512   void *argp1 = 0 ;
5513   int res1 = 0 ;
5514   struct ldb_result *tmp3 ;
5515   PyObject * obj0 = 0 ;
5516   PyObject * obj1 = 0 ;
5517   char *  kwnames[] = {
5518     (char *) "self",(char *) "dn", NULL
5519   };
5520   ldb_error result;
5521
5522   arg3 = &tmp3;
5523   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb___contains__",kwnames,&obj0,&obj1)) SWIG_fail;
5524   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5525   if (!SWIG_IsOK(res1)) {
5526     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___contains__" "', argument " "1"" of type '" "ldb *""'");
5527   }
5528   arg1 = (ldb *)(argp1);
5529   if (ldb_dn_from_pyobject(NULL, obj1, arg1, &arg2) != 0) {
5530     SWIG_fail;
5531   }
5532   if (arg1 == NULL)
5533   SWIG_exception(SWIG_ValueError,
5534     "ldb context must be non-NULL");
5535   result = ldb___contains__(arg1,arg2,arg3);
5536   if (result != 0) {
5537     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_errstring(arg1)));
5538     SWIG_fail;
5539   }
5540   resultobj = Py_None;
5541   resultobj = ((*arg3)->count > 0)?Py_True:Py_False;
5542   talloc_free(arg2);
5543   talloc_free(*arg3);
5544   return resultobj;
5545 fail:
5546   talloc_free(arg2);
5547   talloc_free(*arg3);
5548   return NULL;
5549 }
5550
5551
5552 SWIGINTERN PyObject *_wrap_Ldb_parse_ldif(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5553   PyObject *resultobj = 0;
5554   ldb *arg1 = (ldb *) 0 ;
5555   char *arg2 = (char *) 0 ;
5556   void *argp1 = 0 ;
5557   int res1 = 0 ;
5558   int res2 ;
5559   char *buf2 = 0 ;
5560   int alloc2 = 0 ;
5561   PyObject * obj0 = 0 ;
5562   PyObject * obj1 = 0 ;
5563   char *  kwnames[] = {
5564     (char *) "self",(char *) "s", NULL
5565   };
5566   PyObject *result = 0 ;
5567
5568   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Ldb_parse_ldif",kwnames,&obj0,&obj1)) SWIG_fail;
5569   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5570   if (!SWIG_IsOK(res1)) {
5571     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb_parse_ldif" "', argument " "1"" of type '" "ldb *""'");
5572   }
5573   arg1 = (ldb *)(argp1);
5574   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5575   if (!SWIG_IsOK(res2)) {
5576     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Ldb_parse_ldif" "', argument " "2"" of type '" "char const *""'");
5577   }
5578   arg2 = (char *)(buf2);
5579   if (arg1 == NULL)
5580   SWIG_exception(SWIG_ValueError,
5581     "ldb context must be non-NULL");
5582   result = (PyObject *)ldb_parse_ldif(arg1,(char const *)arg2);
5583   resultobj = result;
5584   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5585   return resultobj;
5586 fail:
5587   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5588   return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *_wrap_Ldb___repr__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593   PyObject *resultobj = 0;
5594   ldb *arg1 = (ldb *) 0 ;
5595   void *argp1 = 0 ;
5596   int res1 = 0 ;
5597   PyObject *swig_obj[1] ;
5598   char *result = 0 ;
5599
5600   if (!args) SWIG_fail;
5601   swig_obj[0] = args;
5602   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ldb_context, 0 |  0 );
5603   if (!SWIG_IsOK(res1)) {
5604     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Ldb___repr__" "', argument " "1"" of type '" "ldb *""'");
5605   }
5606   arg1 = (ldb *)(argp1);
5607   if (arg1 == NULL)
5608   SWIG_exception(SWIG_ValueError,
5609     "ldb context must be non-NULL");
5610   result = (char *)ldb___repr__(arg1);
5611   resultobj = SWIG_FromCharPtr((const char *)result);
5612   return resultobj;
5613 fail:
5614   return NULL;
5615 }
5616
5617
5618 SWIGINTERN PyObject *Ldb_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5619   PyObject *obj;
5620   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5621   SWIG_TypeNewClientData(SWIGTYPE_p_ldb_context, SWIG_NewClientData(obj));
5622   return SWIG_Py_Void();
5623 }
5624
5625 SWIGINTERN PyObject *Ldb_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5626   return SWIG_Python_InitShadowInstance(args);
5627 }
5628
5629 SWIGINTERN PyObject *_wrap_valid_attr_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5630   PyObject *resultobj = 0;
5631   char *arg1 = (char *) 0 ;
5632   int res1 ;
5633   char *buf1 = 0 ;
5634   int alloc1 = 0 ;
5635   PyObject * obj0 = 0 ;
5636   char *  kwnames[] = {
5637     (char *) "s", NULL
5638   };
5639   int result;
5640
5641   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:valid_attr_name",kwnames,&obj0)) SWIG_fail;
5642   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5643   if (!SWIG_IsOK(res1)) {
5644     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "valid_attr_name" "', argument " "1"" of type '" "char const *""'");
5645   }
5646   arg1 = (char *)(buf1);
5647   result = (int)ldb_valid_attr_name((char const *)arg1);
5648   resultobj = SWIG_From_int((int)(result));
5649   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5650   return resultobj;
5651 fail:
5652   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5653   return NULL;
5654 }
5655
5656
5657 SWIGINTERN PyObject *_wrap_timestring(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5658   PyObject *resultobj = 0;
5659   time_t arg1 ;
5660   unsigned long val1 ;
5661   int ecode1 = 0 ;
5662   PyObject * obj0 = 0 ;
5663   char *  kwnames[] = {
5664     (char *) "t", NULL
5665   };
5666   char *result = 0 ;
5667
5668   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:timestring",kwnames,&obj0)) SWIG_fail;
5669   ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1);
5670   if (!SWIG_IsOK(ecode1)) {
5671     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "timestring" "', argument " "1"" of type '" "time_t""'");
5672   }
5673   arg1 = (time_t)(val1);
5674   result = (char *)timestring(arg1);
5675   resultobj = SWIG_FromCharPtr((const char *)result);
5676   return resultobj;
5677 fail:
5678   return NULL;
5679 }
5680
5681
5682 SWIGINTERN PyObject *_wrap_string_to_time(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5683   PyObject *resultobj = 0;
5684   char *arg1 = (char *) 0 ;
5685   int res1 ;
5686   char *buf1 = 0 ;
5687   int alloc1 = 0 ;
5688   PyObject * obj0 = 0 ;
5689   char *  kwnames[] = {
5690     (char *) "s", NULL
5691   };
5692   time_t result;
5693
5694   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:string_to_time",kwnames,&obj0)) SWIG_fail;
5695   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
5696   if (!SWIG_IsOK(res1)) {
5697     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_to_time" "', argument " "1"" of type '" "char const *""'");
5698   }
5699   arg1 = (char *)(buf1);
5700   result = (time_t)ldb_string_to_time((char const *)arg1);
5701   resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5702   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5703   return resultobj;
5704 fail:
5705   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5706   return NULL;
5707 }
5708
5709
5710 SWIGINTERN PyObject *_wrap_register_module(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5711   PyObject *resultobj = 0;
5712   struct ldb_module_ops *arg1 = (struct ldb_module_ops *) 0 ;
5713   PyObject * obj0 = 0 ;
5714   char *  kwnames[] = {
5715     (char *)"arg1", NULL
5716   };
5717   ldb_int_error result;
5718
5719   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:register_module",kwnames,&obj0)) SWIG_fail;
5720   arg1 = talloc_zero(talloc_autofree_context(), struct ldb_module_ops);
5721
5722   arg1->name = (char *)PyObject_GetAttrString(obj0, (char *)"name");
5723   result = ldb_register_module((struct ldb_module_ops const *)arg1);
5724   if (result != 0) {
5725     PyErr_SetObject(PyExc_LdbError, Py_BuildValue((char *)"(i,s)", result, ldb_strerror(result)));
5726     SWIG_fail;
5727   }
5728   resultobj = Py_None;
5729   return resultobj;
5730 fail:
5731   return NULL;
5732 }
5733
5734
5735 static PyMethodDef SwigMethods[] = {
5736          { (char *)"ldb_val_to_py_object", (PyCFunction) _wrap_ldb_val_to_py_object, METH_VARARGS | METH_KEYWORDS, NULL},
5737          { (char *)"new_Dn", (PyCFunction) _wrap_new_Dn, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5738                 "S.__init__(ldb, string)\n"
5739                 "Create a new DN.\n"
5740                 ""},
5741          { (char *)"delete_Dn", (PyCFunction)_wrap_delete_Dn, METH_O, NULL},
5742          { (char *)"Dn_validate", (PyCFunction)_wrap_Dn_validate, METH_O, (char *)"\n"
5743                 "S.validate() -> bool\n"
5744                 "Validate DN is correct.\n"
5745                 ""},
5746          { (char *)"Dn_get_casefold", (PyCFunction)_wrap_Dn_get_casefold, METH_O, NULL},
5747          { (char *)"Dn___str__", (PyCFunction)_wrap_Dn___str__, METH_O, NULL},
5748          { (char *)"Dn_parent", (PyCFunction)_wrap_Dn_parent, METH_O, (char *)"\n"
5749                 "S.parent() -> dn\n"
5750                 "Get the parent for this DN.\n"
5751                 ""},
5752          { (char *)"Dn___cmp__", (PyCFunction) _wrap_Dn___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
5753          { (char *)"Dn_is_valid", (PyCFunction)_wrap_Dn_is_valid, METH_O, NULL},
5754          { (char *)"Dn_is_special", (PyCFunction)_wrap_Dn_is_special, METH_O, (char *)"\n"
5755                 "S.is_special() -> bool\n"
5756                 "Check whether this is a special LDB DN.\n"
5757                 ""},
5758          { (char *)"Dn_is_null", (PyCFunction)_wrap_Dn_is_null, METH_O, (char *)"\n"
5759                 "S.is_null() -> bool\n"
5760                 "Check whether this is a null DN.\n"
5761                 ""},
5762          { (char *)"Dn_check_special", (PyCFunction) _wrap_Dn_check_special, METH_VARARGS | METH_KEYWORDS, NULL},
5763          { (char *)"Dn___len__", (PyCFunction)_wrap_Dn___len__, METH_O, NULL},
5764          { (char *)"Dn_add_child", (PyCFunction) _wrap_Dn_add_child, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5765                 "S.add_child(dn) -> None\n"
5766                 "Add a child DN to this DN.\n"
5767                 ""},
5768          { (char *)"Dn_add_base", (PyCFunction) _wrap_Dn_add_base, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5769                 "S.add_base(dn) -> None\n"
5770                 "Add a base DN to this DN.\n"
5771                 ""},
5772          { (char *)"Dn_canonical_str", (PyCFunction)_wrap_Dn_canonical_str, METH_O, (char *)"\n"
5773                 "S.canonical_str() -> string\n"
5774                 "Canonical version of this DN (like a posix path).\n"
5775                 ""},
5776          { (char *)"Dn_canonical_ex_str", (PyCFunction)_wrap_Dn_canonical_ex_str, METH_O, (char *)"\n"
5777                 "S.canonical_ex_str() -> string\n"
5778                 "Canonical version of this DN (like a posix path, with terminating newline).\n"
5779                 ""},
5780          { (char *)"Dn___repr__", (PyCFunction)_wrap_Dn___repr__, METH_O, NULL},
5781          { (char *)"Dn___add__", (PyCFunction) _wrap_Dn___add__, METH_VARARGS | METH_KEYWORDS, NULL},
5782          { (char *)"Dn_swigregister", Dn_swigregister, METH_VARARGS, NULL},
5783          { (char *)"Dn_swiginit", Dn_swiginit, METH_VARARGS, NULL},
5784          { (char *)"MessageElement___cmp__", (PyCFunction) _wrap_MessageElement___cmp__, METH_VARARGS | METH_KEYWORDS, NULL},
5785          { (char *)"MessageElement___iter__", (PyCFunction)_wrap_MessageElement___iter__, METH_O, NULL},
5786          { (char *)"MessageElement___set__", (PyCFunction)_wrap_MessageElement___set__, METH_O, NULL},
5787          { (char *)"new_MessageElement", (PyCFunction) _wrap_new_MessageElement, METH_VARARGS | METH_KEYWORDS, (char *)"Message element."},
5788          { (char *)"MessageElement___len__", (PyCFunction)_wrap_MessageElement___len__, METH_O, NULL},
5789          { (char *)"MessageElement_get", (PyCFunction) _wrap_MessageElement_get, METH_VARARGS | METH_KEYWORDS, NULL},
5790          { (char *)"delete_MessageElement", (PyCFunction)_wrap_delete_MessageElement, METH_O, NULL},
5791          { (char *)"MessageElement_swigregister", MessageElement_swigregister, METH_VARARGS, NULL},
5792          { (char *)"MessageElement_swiginit", MessageElement_swiginit, METH_VARARGS, NULL},
5793          { (char *)"ldb_msg_list_elements", (PyCFunction) _wrap_ldb_msg_list_elements, METH_VARARGS | METH_KEYWORDS, NULL},
5794          { (char *)"Message_dn_set", _wrap_Message_dn_set, METH_VARARGS, NULL},
5795          { (char *)"Message_dn_get", (PyCFunction)_wrap_Message_dn_get, METH_O, NULL},
5796          { (char *)"new_Message", (PyCFunction) _wrap_new_Message, METH_VARARGS | METH_KEYWORDS, NULL},
5797          { (char *)"delete_Message", (PyCFunction)_wrap_delete_Message, METH_O, NULL},
5798          { (char *)"Message_find_element", (PyCFunction) _wrap_Message_find_element, METH_VARARGS | METH_KEYWORDS, NULL},
5799          { (char *)"Message___setitem__", _wrap_Message___setitem__, METH_VARARGS, NULL},
5800          { (char *)"Message___len__", (PyCFunction)_wrap_Message___len__, METH_O, NULL},
5801          { (char *)"Message_keys", (PyCFunction)_wrap_Message_keys, METH_O, NULL},
5802          { (char *)"Message___iter__", (PyCFunction)_wrap_Message___iter__, METH_O, NULL},
5803          { (char *)"Message___delitem__", (PyCFunction) _wrap_Message___delitem__, METH_VARARGS | METH_KEYWORDS, NULL},
5804          { (char *)"Message_swigregister", Message_swigregister, METH_VARARGS, NULL},
5805          { (char *)"Message_swiginit", Message_swiginit, METH_VARARGS, NULL},
5806          { (char *)"ldb_ldif_to_pyobject", (PyCFunction) _wrap_ldb_ldif_to_pyobject, METH_VARARGS | METH_KEYWORDS, NULL},
5807          { (char *)"new_Ldb", (PyCFunction)_wrap_new_Ldb, METH_NOARGS, NULL},
5808          { (char *)"Ldb_connect", (PyCFunction) _wrap_Ldb_connect, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5809                 "S.connect(url,flags=0,options=None) -> None\n"
5810                 "Connect to a LDB URL.\n"
5811                 ""},
5812          { (char *)"delete_Ldb", (PyCFunction)_wrap_delete_Ldb, METH_O, NULL},
5813          { (char *)"Ldb_search_ex", (PyCFunction) _wrap_Ldb_search_ex, METH_VARARGS | METH_KEYWORDS, NULL},
5814          { (char *)"Ldb_delete", (PyCFunction) _wrap_Ldb_delete, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5815                 "S.delete(dn) -> None\n"
5816                 "Remove an entry.\n"
5817                 ""},
5818          { (char *)"Ldb_rename", (PyCFunction) _wrap_Ldb_rename, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5819                 "S.rename(old_dn, new_dn) -> None\n"
5820                 "Rename an entry.\n"
5821                 ""},
5822          { (char *)"Ldb_parse_control_strings", (PyCFunction) _wrap_Ldb_parse_control_strings, METH_VARARGS | METH_KEYWORDS, NULL},
5823          { (char *)"Ldb_add", (PyCFunction) _wrap_Ldb_add, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5824                 "S.add(message) -> None\n"
5825                 "Add an entry.\n"
5826                 ""},
5827          { (char *)"Ldb_modify", (PyCFunction) _wrap_Ldb_modify, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5828                 "S.modify(message) -> None\n"
5829                 "Modify an entry.\n"
5830                 ""},
5831          { (char *)"Ldb_get_config_basedn", (PyCFunction)_wrap_Ldb_get_config_basedn, METH_O, NULL},
5832          { (char *)"Ldb_get_root_basedn", (PyCFunction)_wrap_Ldb_get_root_basedn, METH_O, NULL},
5833          { (char *)"Ldb_get_schema_basedn", (PyCFunction)_wrap_Ldb_get_schema_basedn, METH_O, NULL},
5834          { (char *)"Ldb_get_default_basedn", (PyCFunction)_wrap_Ldb_get_default_basedn, METH_O, NULL},
5835          { (char *)"Ldb_schema_format_value", (PyCFunction) _wrap_Ldb_schema_format_value, METH_VARARGS | METH_KEYWORDS, NULL},
5836          { (char *)"Ldb_errstring", (PyCFunction)_wrap_Ldb_errstring, METH_O, NULL},
5837          { (char *)"Ldb_set_create_perms", (PyCFunction) _wrap_Ldb_set_create_perms, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5838                 "S.set_create_perms(mode) -> None\n"
5839                 "Set mode to use when creating new LDB files.\n"
5840                 ""},
5841          { (char *)"Ldb_set_modules_dir", (PyCFunction) _wrap_Ldb_set_modules_dir, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5842                 "S.set_modules_dir(path) -> None\n"
5843                 "Set path LDB should search for modules\n"
5844                 ""},
5845          { (char *)"Ldb_set_debug", (PyCFunction) _wrap_Ldb_set_debug, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5846                 "S.set_debug(callback) -> None\n"
5847                 "Set callback for LDB debug messages.\n"
5848                 "The callback should accept a debug level and debug text.\n"
5849                 ""},
5850          { (char *)"Ldb_set_opaque", (PyCFunction) _wrap_Ldb_set_opaque, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5851                 "S.set_opaque(name, value) -> None\n"
5852                 "Set an opaque value on this LDB connection. \n"
5853                 ":note: Passing incorrect values may cause crashes.\n"
5854                 ""},
5855          { (char *)"Ldb_get_opaque", (PyCFunction) _wrap_Ldb_get_opaque, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5856                 "S.get_opaque(name) -> value\n"
5857                 "Get an opaque value set on this LDB connection. \n"
5858                 ":note: The returned value may not be useful in Python.\n"
5859                 ""},
5860          { (char *)"Ldb_transaction_start", (PyCFunction)_wrap_Ldb_transaction_start, METH_O, (char *)"\n"
5861                 "S.transaction_start() -> None\n"
5862                 "Start a new transaction.\n"
5863                 ""},
5864          { (char *)"Ldb_transaction_commit", (PyCFunction)_wrap_Ldb_transaction_commit, METH_O, (char *)"\n"
5865                 "S.transaction_commit() -> None\n"
5866                 "Commit currently active transaction.\n"
5867                 ""},
5868          { (char *)"Ldb_transaction_cancel", (PyCFunction)_wrap_Ldb_transaction_cancel, METH_O, (char *)"\n"
5869                 "S.transaction_cancel() -> None\n"
5870                 "Cancel currently active transaction.\n"
5871                 ""},
5872          { (char *)"Ldb_schema_attribute_remove", (PyCFunction) _wrap_Ldb_schema_attribute_remove, METH_VARARGS | METH_KEYWORDS, NULL},
5873          { (char *)"Ldb_schema_attribute_add", (PyCFunction) _wrap_Ldb_schema_attribute_add, METH_VARARGS | METH_KEYWORDS, NULL},
5874          { (char *)"Ldb_setup_wellknown_attributes", (PyCFunction)_wrap_Ldb_setup_wellknown_attributes, METH_O, NULL},
5875          { (char *)"Ldb___contains__", (PyCFunction) _wrap_Ldb___contains__, METH_VARARGS | METH_KEYWORDS, NULL},
5876          { (char *)"Ldb_parse_ldif", (PyCFunction) _wrap_Ldb_parse_ldif, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5877                 "S.parse_ldif(ldif) -> iter(messages)\n"
5878                 "Parse a string formatted using LDIF.\n"
5879                 ""},
5880          { (char *)"Ldb___repr__", (PyCFunction)_wrap_Ldb___repr__, METH_O, NULL},
5881          { (char *)"Ldb_swigregister", Ldb_swigregister, METH_VARARGS, NULL},
5882          { (char *)"Ldb_swiginit", Ldb_swiginit, METH_VARARGS, NULL},
5883          { (char *)"valid_attr_name", (PyCFunction) _wrap_valid_attr_name, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5884                 "S.valid_attr_name(name) -> bool\n"
5885                 "Check whether the supplied name is a valid attribute name.\n"
5886                 ""},
5887          { (char *)"timestring", (PyCFunction) _wrap_timestring, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5888                 "S.timestring(int) -> string\n"
5889                 "Generate a LDAP time string from a UNIX timestamp\n"
5890                 ""},
5891          { (char *)"string_to_time", (PyCFunction) _wrap_string_to_time, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5892                 "S.string_to_time(string) -> int\n"
5893                 "Parse a LDAP time string into a UNIX timestamp.\n"
5894                 ""},
5895          { (char *)"register_module", (PyCFunction) _wrap_register_module, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
5896                 "S.register_module(module) -> None\n"
5897                 "Register a LDB module.\n"
5898                 ""},
5899          { NULL, NULL, 0, NULL }
5900 };
5901
5902
5903 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5904
5905 static swig_type_info _swigt__p_TALLOC_CTX = {"_p_TALLOC_CTX", "TALLOC_CTX *", 0, 0, (void*)0, 0};
5906 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
5907 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};
5908 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};
5909 static swig_type_info _swigt__p_ldb_context = {"_p_ldb_context", "struct ldb_context *|ldb *", 0, 0, (void*)0, 0};
5910 static swig_type_info _swigt__p_ldb_dn = {"_p_ldb_dn", "struct ldb_dn *|ldb_dn *", 0, 0, (void*)0, 0};
5911 static swig_type_info _swigt__p_ldb_ldif = {"_p_ldb_ldif", "struct ldb_ldif *|ldb_ldif *", 0, 0, (void*)0, 0};
5912 static swig_type_info _swigt__p_ldb_message = {"_p_ldb_message", "ldb_msg *|struct ldb_message *", 0, 0, (void*)0, 0};
5913 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};
5914 static swig_type_info _swigt__p_ldb_module_ops = {"_p_ldb_module_ops", "struct ldb_module_ops *", 0, 0, (void*)0, 0};
5915 static swig_type_info _swigt__p_ldb_result = {"_p_ldb_result", "struct ldb_result *", 0, 0, (void*)0, 0};
5916 static swig_type_info _swigt__p_ldb_val = {"_p_ldb_val", "struct ldb_val *", 0, 0, (void*)0, 0};
5917 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};
5918 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
5919 static swig_type_info _swigt__p_p_ldb_control = {"_p_p_ldb_control", "struct ldb_control **", 0, 0, (void*)0, 0};
5920 static swig_type_info _swigt__p_p_ldb_result = {"_p_p_ldb_result", "struct ldb_result **", 0, 0, (void*)0, 0};
5921 static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
5922 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};
5923 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};
5924 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};
5925 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|time_t *", 0, 0, (void*)0, 0};
5926 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};
5927 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
5928 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
5929
5930 static swig_type_info *swig_type_initial[] = {
5931   &_swigt__p_TALLOC_CTX,
5932   &_swigt__p_char,
5933   &_swigt__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
5934   &_swigt__p_int,
5935   &_swigt__p_ldb_context,
5936   &_swigt__p_ldb_dn,
5937   &_swigt__p_ldb_ldif,
5938   &_swigt__p_ldb_message,
5939   &_swigt__p_ldb_message_element,
5940   &_swigt__p_ldb_module_ops,
5941   &_swigt__p_ldb_result,
5942   &_swigt__p_ldb_val,
5943   &_swigt__p_long_long,
5944   &_swigt__p_p_char,
5945   &_swigt__p_p_ldb_control,
5946   &_swigt__p_p_ldb_result,
5947   &_swigt__p_short,
5948   &_swigt__p_signed_char,
5949   &_swigt__p_unsigned_char,
5950   &_swigt__p_unsigned_int,
5951   &_swigt__p_unsigned_long,
5952   &_swigt__p_unsigned_long_long,
5953   &_swigt__p_unsigned_short,
5954   &_swigt__p_void,
5955 };
5956
5957 static swig_cast_info _swigc__p_TALLOC_CTX[] = {  {&_swigt__p_TALLOC_CTX, 0, 0, 0},{0, 0, 0, 0}};
5958 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
5959 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}};
5960 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
5961 static swig_cast_info _swigc__p_ldb_context[] = {  {&_swigt__p_ldb_context, 0, 0, 0},{0, 0, 0, 0}};
5962 static swig_cast_info _swigc__p_ldb_dn[] = {  {&_swigt__p_ldb_dn, 0, 0, 0},{0, 0, 0, 0}};
5963 static swig_cast_info _swigc__p_ldb_ldif[] = {  {&_swigt__p_ldb_ldif, 0, 0, 0},{0, 0, 0, 0}};
5964 static swig_cast_info _swigc__p_ldb_message[] = {  {&_swigt__p_ldb_message, 0, 0, 0},{0, 0, 0, 0}};
5965 static swig_cast_info _swigc__p_ldb_message_element[] = {  {&_swigt__p_ldb_message_element, 0, 0, 0},{0, 0, 0, 0}};
5966 static swig_cast_info _swigc__p_ldb_module_ops[] = {  {&_swigt__p_ldb_module_ops, 0, 0, 0},{0, 0, 0, 0}};
5967 static swig_cast_info _swigc__p_ldb_result[] = {  {&_swigt__p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
5968 static swig_cast_info _swigc__p_ldb_val[] = {  {&_swigt__p_ldb_val, 0, 0, 0},{0, 0, 0, 0}};
5969 static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
5970 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
5971 static swig_cast_info _swigc__p_p_ldb_control[] = {  {&_swigt__p_p_ldb_control, 0, 0, 0},{0, 0, 0, 0}};
5972 static swig_cast_info _swigc__p_p_ldb_result[] = {  {&_swigt__p_p_ldb_result, 0, 0, 0},{0, 0, 0, 0}};
5973 static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
5974 static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
5975 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
5976 static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
5977 static swig_cast_info _swigc__p_unsigned_long[] = {  {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
5978 static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
5979 static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
5980 static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
5981
5982 static swig_cast_info *swig_cast_initial[] = {
5983   _swigc__p_TALLOC_CTX,
5984   _swigc__p_char,
5985   _swigc__p_f_p_void_enum_ldb_debug_level_p_q_const__char_va_list__void,
5986   _swigc__p_int,
5987   _swigc__p_ldb_context,
5988   _swigc__p_ldb_dn,
5989   _swigc__p_ldb_ldif,
5990   _swigc__p_ldb_message,
5991   _swigc__p_ldb_message_element,
5992   _swigc__p_ldb_module_ops,
5993   _swigc__p_ldb_result,
5994   _swigc__p_ldb_val,
5995   _swigc__p_long_long,
5996   _swigc__p_p_char,
5997   _swigc__p_p_ldb_control,
5998   _swigc__p_p_ldb_result,
5999   _swigc__p_short,
6000   _swigc__p_signed_char,
6001   _swigc__p_unsigned_char,
6002   _swigc__p_unsigned_int,
6003   _swigc__p_unsigned_long,
6004   _swigc__p_unsigned_long_long,
6005   _swigc__p_unsigned_short,
6006   _swigc__p_void,
6007 };
6008
6009
6010 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6011
6012 static swig_const_info swig_const_table[] = {
6013 {0, 0, 0, 0.0, 0, 0}};
6014
6015 #ifdef __cplusplus
6016 }
6017 #endif
6018 /* -----------------------------------------------------------------------------
6019  * Type initialization:
6020  * This problem is tough by the requirement that no dynamic
6021  * memory is used. Also, since swig_type_info structures store pointers to
6022  * swig_cast_info structures and swig_cast_info structures store pointers back
6023  * to swig_type_info structures, we need some lookup code at initialization.
6024  * The idea is that swig generates all the structures that are needed.
6025  * The runtime then collects these partially filled structures.
6026  * The SWIG_InitializeModule function takes these initial arrays out of
6027  * swig_module, and does all the lookup, filling in the swig_module.types
6028  * array with the correct data and linking the correct swig_cast_info
6029  * structures together.
6030  *
6031  * The generated swig_type_info structures are assigned staticly to an initial
6032  * array. We just loop through that array, and handle each type individually.
6033  * First we lookup if this type has been already loaded, and if so, use the
6034  * loaded structure instead of the generated one. Then we have to fill in the
6035  * cast linked list. The cast data is initially stored in something like a
6036  * two-dimensional array. Each row corresponds to a type (there are the same
6037  * number of rows as there are in the swig_type_initial array). Each entry in
6038  * a column is one of the swig_cast_info structures for that type.
6039  * The cast_initial array is actually an array of arrays, because each row has
6040  * a variable number of columns. So to actually build the cast linked list,
6041  * we find the array of casts associated with the type, and loop through it
6042  * adding the casts to the list. The one last trick we need to do is making
6043  * sure the type pointer in the swig_cast_info struct is correct.
6044  *
6045  * First off, we lookup the cast->type name to see if it is already loaded.
6046  * There are three cases to handle:
6047  *  1) If the cast->type has already been loaded AND the type we are adding
6048  *     casting info to has not been loaded (it is in this module), THEN we
6049  *     replace the cast->type pointer with the type pointer that has already
6050  *     been loaded.
6051  *  2) If BOTH types (the one we are adding casting info to, and the
6052  *     cast->type) are loaded, THEN the cast info has already been loaded by
6053  *     the previous module so we just ignore it.
6054  *  3) Finally, if cast->type has not already been loaded, then we add that
6055  *     swig_cast_info to the linked list (because the cast->type) pointer will
6056  *     be correct.
6057  * ----------------------------------------------------------------------------- */
6058
6059 #ifdef __cplusplus
6060 extern "C" {
6061 #if 0
6062 } /* c-mode */
6063 #endif
6064 #endif
6065
6066 #if 0
6067 #define SWIGRUNTIME_DEBUG
6068 #endif
6069
6070
6071 SWIGRUNTIME void
6072 SWIG_InitializeModule(void *clientdata) {
6073   size_t i;
6074   swig_module_info *module_head, *iter;
6075   int found, init;
6076
6077   clientdata = clientdata;
6078
6079   /* check to see if the circular list has been setup, if not, set it up */
6080   if (swig_module.next==0) {
6081     /* Initialize the swig_module */
6082     swig_module.type_initial = swig_type_initial;
6083     swig_module.cast_initial = swig_cast_initial;
6084     swig_module.next = &swig_module;
6085     init = 1;
6086   } else {
6087     init = 0;
6088   }
6089
6090   /* Try and load any already created modules */
6091   module_head = SWIG_GetModule(clientdata);
6092   if (!module_head) {
6093     /* This is the first module loaded for this interpreter */
6094     /* so set the swig module into the interpreter */
6095     SWIG_SetModule(clientdata, &swig_module);
6096     module_head = &swig_module;
6097   } else {
6098     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
6099     found=0;
6100     iter=module_head;
6101     do {
6102       if (iter==&swig_module) {
6103         found=1;
6104         break;
6105       }
6106       iter=iter->next;
6107     } while (iter!= module_head);
6108
6109     /* if the is found in the list, then all is done and we may leave */
6110     if (found) return;
6111     /* otherwise we must add out module into the list */
6112     swig_module.next = module_head->next;
6113     module_head->next = &swig_module;
6114   }
6115
6116   /* When multiple interpeters are used, a module could have already been initialized in
6117        a different interpreter, but not yet have a pointer in this interpreter.
6118        In this case, we do not want to continue adding types... everything should be
6119        set up already */
6120   if (init == 0) return;
6121
6122   /* Now work on filling in swig_module.types */
6123 #ifdef SWIGRUNTIME_DEBUG
6124   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
6125 #endif
6126   for (i = 0; i < swig_module.size; ++i) {
6127     swig_type_info *type = 0;
6128     swig_type_info *ret;
6129     swig_cast_info *cast;
6130
6131 #ifdef SWIGRUNTIME_DEBUG
6132     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6133 #endif
6134
6135     /* if there is another module already loaded */
6136     if (swig_module.next != &swig_module) {
6137       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
6138     }
6139     if (type) {
6140       /* Overwrite clientdata field */
6141 #ifdef SWIGRUNTIME_DEBUG
6142       printf("SWIG_InitializeModule: found type %s\n", type->name);
6143 #endif
6144       if (swig_module.type_initial[i]->clientdata) {
6145         type->clientdata = swig_module.type_initial[i]->clientdata;
6146 #ifdef SWIGRUNTIME_DEBUG
6147         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
6148 #endif
6149       }
6150     } else {
6151       type = swig_module.type_initial[i];
6152     }
6153
6154     /* Insert casting types */
6155     cast = swig_module.cast_initial[i];
6156     while (cast->type) {
6157       /* Don't need to add information already in the list */
6158       ret = 0;
6159 #ifdef SWIGRUNTIME_DEBUG
6160       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
6161 #endif
6162       if (swig_module.next != &swig_module) {
6163         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
6164 #ifdef SWIGRUNTIME_DEBUG
6165         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
6166 #endif
6167       }
6168       if (ret) {
6169         if (type == swig_module.type_initial[i]) {
6170 #ifdef SWIGRUNTIME_DEBUG
6171           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
6172 #endif
6173           cast->type = ret;
6174           ret = 0;
6175         } else {
6176           /* Check for casting already in the list */
6177           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
6178 #ifdef SWIGRUNTIME_DEBUG
6179           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
6180 #endif
6181           if (!ocast) ret = 0;
6182         }
6183       }
6184
6185       if (!ret) {
6186 #ifdef SWIGRUNTIME_DEBUG
6187         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
6188 #endif
6189         if (type->cast) {
6190           type->cast->prev = cast;
6191           cast->next = type->cast;
6192         }
6193         type->cast = cast;
6194       }
6195       cast++;
6196     }
6197     /* Set entry in modules->types array equal to the type */
6198     swig_module.types[i] = type;
6199   }
6200   swig_module.types[i] = 0;
6201
6202 #ifdef SWIGRUNTIME_DEBUG
6203   printf("**** SWIG_InitializeModule: Cast List ******\n");
6204   for (i = 0; i < swig_module.size; ++i) {
6205     int j = 0;
6206     swig_cast_info *cast = swig_module.cast_initial[i];
6207     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6208     while (cast->type) {
6209       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
6210       cast++;
6211       ++j;
6212     }
6213     printf("---- Total casts: %d\n",j);
6214   }
6215   printf("**** SWIG_InitializeModule: Cast List ******\n");
6216 #endif
6217 }
6218
6219 /* This function will propagate the clientdata field of type to
6220 * any new swig_type_info structures that have been added into the list
6221 * of equivalent types.  It is like calling
6222 * SWIG_TypeClientData(type, clientdata) a second time.
6223 */
6224 SWIGRUNTIME void
6225 SWIG_PropagateClientData(void) {
6226   size_t i;
6227   swig_cast_info *equiv;
6228   static int init_run = 0;
6229
6230   if (init_run) return;
6231   init_run = 1;
6232
6233   for (i = 0; i < swig_module.size; i++) {
6234     if (swig_module.types[i]->clientdata) {
6235       equiv = swig_module.types[i]->cast;
6236       while (equiv) {
6237         if (!equiv->converter) {
6238           if (equiv->type && !equiv->type->clientdata)
6239           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
6240         }
6241         equiv = equiv->next;
6242       }
6243     }
6244   }
6245 }
6246
6247 #ifdef __cplusplus
6248 #if 0
6249 {
6250   /* c-mode */
6251 #endif
6252 }
6253 #endif
6254
6255
6256
6257 #ifdef __cplusplus
6258 extern "C" {
6259 #endif
6260
6261   /* Python-specific SWIG API */
6262 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
6263 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
6264 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
6265
6266   /* -----------------------------------------------------------------------------
6267    * global variable support code.
6268    * ----------------------------------------------------------------------------- */
6269
6270   typedef struct swig_globalvar {
6271     char       *name;                  /* Name of global variable */
6272     PyObject *(*get_attr)(void);       /* Return the current value */
6273     int       (*set_attr)(PyObject *); /* Set the value */
6274     struct swig_globalvar *next;
6275   } swig_globalvar;
6276
6277   typedef struct swig_varlinkobject {
6278     PyObject_HEAD
6279     swig_globalvar *vars;
6280   } swig_varlinkobject;
6281
6282   SWIGINTERN PyObject *
6283   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
6284     return PyString_FromString("<Swig global variables>");
6285   }
6286
6287   SWIGINTERN PyObject *
6288   swig_varlink_str(swig_varlinkobject *v) {
6289     PyObject *str = PyString_FromString("(");
6290     swig_globalvar  *var;
6291     for (var = v->vars; var; var=var->next) {
6292       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
6293       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
6294     }
6295     PyString_ConcatAndDel(&str,PyString_FromString(")"));
6296     return str;
6297   }
6298
6299   SWIGINTERN int
6300   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
6301     PyObject *str = swig_varlink_str(v);
6302     fprintf(fp,"Swig global variables ");
6303     fprintf(fp,"%s\n", PyString_AsString(str));
6304     Py_DECREF(str);
6305     return 0;
6306   }
6307
6308   SWIGINTERN void
6309   swig_varlink_dealloc(swig_varlinkobject *v) {
6310     swig_globalvar *var = v->vars;
6311     while (var) {
6312       swig_globalvar *n = var->next;
6313       free(var->name);
6314       free(var);
6315       var = n;
6316     }
6317   }
6318
6319   SWIGINTERN PyObject *
6320   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
6321     PyObject *res = NULL;
6322     swig_globalvar *var = v->vars;
6323     while (var) {
6324       if (strcmp(var->name,n) == 0) {
6325         res = (*var->get_attr)();
6326         break;
6327       }
6328       var = var->next;
6329     }
6330     if (res == NULL && !PyErr_Occurred()) {
6331       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6332     }
6333     return res;
6334   }
6335
6336   SWIGINTERN int
6337   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
6338     int res = 1;
6339     swig_globalvar *var = v->vars;
6340     while (var) {
6341       if (strcmp(var->name,n) == 0) {
6342         res = (*var->set_attr)(p);
6343         break;
6344       }
6345       var = var->next;
6346     }
6347     if (res == 1 && !PyErr_Occurred()) {
6348       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6349     }
6350     return res;
6351   }
6352
6353   SWIGINTERN PyTypeObject*
6354   swig_varlink_type(void) {
6355     static char varlink__doc__[] = "Swig var link object";
6356     static PyTypeObject varlink_type;
6357     static int type_init = 0;
6358     if (!type_init) {
6359       const PyTypeObject tmp
6360       = {
6361         PyObject_HEAD_INIT(NULL)
6362         0,                                  /* Number of items in variable part (ob_size) */
6363         (char *)"swigvarlink",              /* Type name (tp_name) */
6364         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
6365         0,                                  /* Itemsize (tp_itemsize) */
6366         (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */
6367         (printfunc) swig_varlink_print,     /* Print (tp_print) */
6368         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
6369         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
6370         0,                                  /* tp_compare */
6371         (reprfunc) swig_varlink_repr,       /* tp_repr */
6372         0,                                  /* tp_as_number */
6373         0,                                  /* tp_as_sequence */
6374         0,                                  /* tp_as_mapping */
6375         0,                                  /* tp_hash */
6376         0,                                  /* tp_call */
6377         (reprfunc)swig_varlink_str,        /* tp_str */
6378         0,                                  /* tp_getattro */
6379         0,                                  /* tp_setattro */
6380         0,                                  /* tp_as_buffer */
6381         0,                                  /* tp_flags */
6382         varlink__doc__,                     /* tp_doc */
6383         0,                                  /* tp_traverse */
6384         0,                                  /* tp_clear */
6385         0,                                  /* tp_richcompare */
6386         0,                                  /* tp_weaklistoffset */
6387 #if PY_VERSION_HEX >= 0x02020000
6388         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
6389 #endif
6390 #if PY_VERSION_HEX >= 0x02030000
6391         0,                                  /* tp_del */
6392 #endif
6393 #ifdef COUNT_ALLOCS
6394         0,0,0,0                             /* tp_alloc -> tp_next */
6395 #endif
6396       };
6397       varlink_type = tmp;
6398       varlink_type.ob_type = &PyType_Type;
6399       type_init = 1;
6400     }
6401     return &varlink_type;
6402   }
6403
6404   /* Create a variable linking object for use later */
6405   SWIGINTERN PyObject *
6406   SWIG_Python_newvarlink(void) {
6407     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
6408     if (result) {
6409       result->vars = 0;
6410     }
6411     return ((PyObject*) result);
6412   }
6413
6414   SWIGINTERN void
6415   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
6416     swig_varlinkobject *v = (swig_varlinkobject *) p;
6417     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
6418     if (gv) {
6419       size_t size = strlen(name)+1;
6420       gv->name = (char *)malloc(size);
6421       if (gv->name) {
6422         strncpy(gv->name,name,size);
6423         gv->get_attr = get_attr;
6424         gv->set_attr = set_attr;
6425         gv->next = v->vars;
6426       }
6427     }
6428     v->vars = gv;
6429   }
6430
6431   SWIGINTERN PyObject *
6432   SWIG_globals(void) {
6433     static PyObject *_SWIG_globals = 0;
6434     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
6435     return _SWIG_globals;
6436   }
6437
6438   /* -----------------------------------------------------------------------------
6439    * constants/methods manipulation
6440    * ----------------------------------------------------------------------------- */
6441
6442   /* Install Constants */
6443   SWIGINTERN void
6444   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
6445     PyObject *obj = 0;
6446     size_t i;
6447     for (i = 0; constants[i].type; ++i) {
6448       switch(constants[i].type) {
6449       case SWIG_PY_POINTER:
6450         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
6451         break;
6452       case SWIG_PY_BINARY:
6453         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
6454         break;
6455       default:
6456         obj = 0;
6457         break;
6458       }
6459       if (obj) {
6460         PyDict_SetItemString(d, constants[i].name, obj);
6461         Py_DECREF(obj);
6462       }
6463     }
6464   }
6465
6466   /* -----------------------------------------------------------------------------*/
6467   /* Fix SwigMethods to carry the callback ptrs when needed */
6468   /* -----------------------------------------------------------------------------*/
6469
6470   SWIGINTERN void
6471   SWIG_Python_FixMethods(PyMethodDef *methods,
6472     swig_const_info *const_table,
6473     swig_type_info **types,
6474     swig_type_info **types_initial) {
6475     size_t i;
6476     for (i = 0; methods[i].ml_name; ++i) {
6477       const char *c = methods[i].ml_doc;
6478       if (c && (c = strstr(c, "swig_ptr: "))) {
6479         int j;
6480         swig_const_info *ci = 0;
6481         const char *name = c + 10;
6482         for (j = 0; const_table[j].type; ++j) {
6483           if (strncmp(const_table[j].name, name,
6484               strlen(const_table[j].name)) == 0) {
6485             ci = &(const_table[j]);
6486             break;
6487           }
6488         }
6489         if (ci) {
6490           size_t shift = (ci->ptype) - types;
6491           swig_type_info *ty = types_initial[shift];
6492           size_t ldoc = (c - methods[i].ml_doc);
6493           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
6494           char *ndoc = (char*)malloc(ldoc + lptr + 10);
6495           if (ndoc) {
6496             char *buff = ndoc;
6497             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
6498             if (ptr) {
6499               strncpy(buff, methods[i].ml_doc, ldoc);
6500               buff += ldoc;
6501               strncpy(buff, "swig_ptr: ", 10);
6502               buff += 10;
6503               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
6504               methods[i].ml_doc = ndoc;
6505             }
6506           }
6507         }
6508       }
6509     }
6510   }
6511
6512 #ifdef __cplusplus
6513 }
6514 #endif
6515
6516 /* -----------------------------------------------------------------------------*
6517  *  Partial Init method
6518  * -----------------------------------------------------------------------------*/
6519
6520 #ifdef __cplusplus
6521 extern "C"
6522 #endif
6523 SWIGEXPORT void SWIG_init(void) {
6524   PyObject *m, *d;
6525
6526   /* Fix SwigMethods to carry the callback ptrs when needed */
6527   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
6528
6529   m = Py_InitModule((char *) SWIG_name, SwigMethods);
6530   d = PyModule_GetDict(m);
6531
6532   SWIG_InitializeModule(0);
6533   SWIG_InstallConstants(d,swig_const_table);
6534
6535
6536   SWIG_Python_SetConstant(d, "SCOPE_DEFAULT",SWIG_From_int((int)(LDB_SCOPE_DEFAULT)));
6537   SWIG_Python_SetConstant(d, "SCOPE_BASE",SWIG_From_int((int)(LDB_SCOPE_BASE)));
6538   SWIG_Python_SetConstant(d, "SCOPE_ONELEVEL",SWIG_From_int((int)(LDB_SCOPE_ONELEVEL)));
6539   SWIG_Python_SetConstant(d, "SCOPE_SUBTREE",SWIG_From_int((int)(LDB_SCOPE_SUBTREE)));
6540   SWIG_Python_SetConstant(d, "CHANGETYPE_NONE",SWIG_From_int((int)(LDB_CHANGETYPE_NONE)));
6541   SWIG_Python_SetConstant(d, "CHANGETYPE_ADD",SWIG_From_int((int)(LDB_CHANGETYPE_ADD)));
6542   SWIG_Python_SetConstant(d, "CHANGETYPE_DELETE",SWIG_From_int((int)(LDB_CHANGETYPE_DELETE)));
6543   SWIG_Python_SetConstant(d, "CHANGETYPE_MODIFY",SWIG_From_int((int)(LDB_CHANGETYPE_MODIFY)));
6544
6545   PyExc_LdbError = PyErr_NewException((char *)"_ldb.LdbError", NULL, NULL);
6546   PyDict_SetItemString(d, "LdbError", PyExc_LdbError);
6547
6548   SWIG_Python_SetConstant(d, "LDB_ERR_OPERATIONS_ERROR",SWIG_From_int((int)(1)));
6549   SWIG_Python_SetConstant(d, "LDB_ERR_PROTOCOL_ERROR",SWIG_From_int((int)(2)));
6550   SWIG_Python_SetConstant(d, "LDB_ERR_TIME_LIMIT_EXCEEDED",SWIG_From_int((int)(3)));
6551   SWIG_Python_SetConstant(d, "LDB_ERR_SIZE_LIMIT_EXCEEDED",SWIG_From_int((int)(4)));
6552   SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_FALSE",SWIG_From_int((int)(5)));
6553   SWIG_Python_SetConstant(d, "LDB_ERR_COMPARE_TRUE",SWIG_From_int((int)(6)));
6554   SWIG_Python_SetConstant(d, "LDB_ERR_AUTH_METHOD_NOT_SUPPORTED",SWIG_From_int((int)(7)));
6555   SWIG_Python_SetConstant(d, "LDB_ERR_STRONG_AUTH_REQUIRED",SWIG_From_int((int)(8)));
6556   SWIG_Python_SetConstant(d, "LDB_ERR_REFERRAL",SWIG_From_int((int)(10)));
6557   SWIG_Python_SetConstant(d, "LDB_ERR_ADMIN_LIMIT_EXCEEDED",SWIG_From_int((int)(11)));
6558   SWIG_Python_SetConstant(d, "LDB_ERR_UNSUPPORTED_CRITICAL_EXTENSION",SWIG_From_int((int)(12)));
6559   SWIG_Python_SetConstant(d, "LDB_ERR_CONFIDENTIALITY_REQUIRED",SWIG_From_int((int)(13)));
6560   SWIG_Python_SetConstant(d, "LDB_ERR_SASL_BIND_IN_PROGRESS",SWIG_From_int((int)(14)));
6561   SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_ATTRIBUTE",SWIG_From_int((int)(16)));
6562   SWIG_Python_SetConstant(d, "LDB_ERR_UNDEFINED_ATTRIBUTE_TYPE",SWIG_From_int((int)(17)));
6563   SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_MATCHING",SWIG_From_int((int)(18)));
6564   SWIG_Python_SetConstant(d, "LDB_ERR_CONSTRAINT_VIOLATION",SWIG_From_int((int)(19)));
6565   SWIG_Python_SetConstant(d, "LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS",SWIG_From_int((int)(20)));
6566   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_ATTRIBUTE_SYNTAX",SWIG_From_int((int)(21)));
6567   SWIG_Python_SetConstant(d, "LDB_ERR_NO_SUCH_OBJECT",SWIG_From_int((int)(32)));
6568   SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_PROBLEM",SWIG_From_int((int)(33)));
6569   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_DN_SYNTAX",SWIG_From_int((int)(34)));
6570   SWIG_Python_SetConstant(d, "LDB_ERR_ALIAS_DEREFERENCING_PROBLEM",SWIG_From_int((int)(36)));
6571   SWIG_Python_SetConstant(d, "LDB_ERR_INAPPROPRIATE_AUTHENTICATION",SWIG_From_int((int)(48)));
6572   SWIG_Python_SetConstant(d, "LDB_ERR_INVALID_CREDENTIALS",SWIG_From_int((int)(49)));
6573   SWIG_Python_SetConstant(d, "LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS",SWIG_From_int((int)(50)));
6574   SWIG_Python_SetConstant(d, "LDB_ERR_BUSY",SWIG_From_int((int)(51)));
6575   SWIG_Python_SetConstant(d, "LDB_ERR_UNAVAILABLE",SWIG_From_int((int)(52)));
6576   SWIG_Python_SetConstant(d, "LDB_ERR_UNWILLING_TO_PERFORM",SWIG_From_int((int)(53)));
6577   SWIG_Python_SetConstant(d, "LDB_ERR_LOOP_DETECT",SWIG_From_int((int)(54)));
6578   SWIG_Python_SetConstant(d, "LDB_ERR_NAMING_VIOLATION",SWIG_From_int((int)(64)));
6579   SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_VIOLATION",SWIG_From_int((int)(65)));
6580   SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_NON_LEAF",SWIG_From_int((int)(66)));
6581   SWIG_Python_SetConstant(d, "LDB_ERR_NOT_ALLOWED_ON_RDN",SWIG_From_int((int)(67)));
6582   SWIG_Python_SetConstant(d, "LDB_ERR_ENTRY_ALREADY_EXISTS",SWIG_From_int((int)(68)));
6583   SWIG_Python_SetConstant(d, "LDB_ERR_OBJECT_CLASS_MODS_PROHIBITED",SWIG_From_int((int)(69)));
6584   SWIG_Python_SetConstant(d, "LDB_ERR_AFFECTS_MULTIPLE_DSAS",SWIG_From_int((int)(71)));
6585   SWIG_Python_SetConstant(d, "LDB_ERR_OTHER",SWIG_From_int((int)(80)));
6586 }
6587