source4/lib/ldb/ldb_wrap.c

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