Merge branch 'master' of ssh://git.samba.org/data/git/samba
[ira/wip.git] / lib / tdb / tdb_wrap.c
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 1.3.36
4  * 
5  * This file is not intended to be easily readable and contains a number of 
6  * coding conventions designed to improve portability and efficiency. Do not make
7  * changes to this file unless you know what you are doing--modify the SWIG 
8  * interface file instead. 
9  * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_NO_BUILD_NONE
13 /* -----------------------------------------------------------------------------
14  *  This section contains generic SWIG labels for method/variable
15  *  declarations/attributes, and other compiler dependent labels.
16  * ----------------------------------------------------------------------------- */
17
18 /* template workaround for compilers that cannot correctly implement the C++ standard */
19 #ifndef SWIGTEMPLATEDISAMBIGUATOR
20 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
21 #  define SWIGTEMPLATEDISAMBIGUATOR template
22 # elif defined(__HP_aCC)
23 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
24 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
25 #  define SWIGTEMPLATEDISAMBIGUATOR template
26 # else
27 #  define SWIGTEMPLATEDISAMBIGUATOR
28 # endif
29 #endif
30
31 /* inline attribute */
32 #ifndef SWIGINLINE
33 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
34 #   define SWIGINLINE inline
35 # else
36 #   define SWIGINLINE
37 # endif
38 #endif
39
40 /* attribute recognised by some compilers to avoid 'unused' warnings */
41 #ifndef SWIGUNUSED
42 # if defined(__GNUC__)
43 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
44 #     define SWIGUNUSED __attribute__ ((__unused__)) 
45 #   else
46 #     define SWIGUNUSED
47 #   endif
48 # elif defined(__ICC)
49 #   define SWIGUNUSED __attribute__ ((__unused__)) 
50 # else
51 #   define SWIGUNUSED 
52 # endif
53 #endif
54
55 #ifndef SWIG_MSC_UNSUPPRESS_4505
56 # if defined(_MSC_VER)
57 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
58 # endif 
59 #endif
60
61 #ifndef SWIGUNUSEDPARM
62 # ifdef __cplusplus
63 #   define SWIGUNUSEDPARM(p)
64 # else
65 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
66 # endif
67 #endif
68
69 /* internal SWIG method */
70 #ifndef SWIGINTERN
71 # define SWIGINTERN static SWIGUNUSED
72 #endif
73
74 /* internal inline SWIG method */
75 #ifndef SWIGINTERNINLINE
76 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
77 #endif
78
79 /* exporting methods */
80 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
81 #  ifndef GCC_HASCLASSVISIBILITY
82 #    define GCC_HASCLASSVISIBILITY
83 #  endif
84 #endif
85
86 #ifndef SWIGEXPORT
87 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
88 #   if defined(STATIC_LINKED)
89 #     define SWIGEXPORT
90 #   else
91 #     define SWIGEXPORT __declspec(dllexport)
92 #   endif
93 # else
94 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
95 #     define SWIGEXPORT __attribute__ ((visibility("default")))
96 #   else
97 #     define SWIGEXPORT
98 #   endif
99 # endif
100 #endif
101
102 /* calling conventions for Windows */
103 #ifndef SWIGSTDCALL
104 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
105 #   define SWIGSTDCALL __stdcall
106 # else
107 #   define SWIGSTDCALL
108 # endif 
109 #endif
110
111 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
112 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
113 # define _CRT_SECURE_NO_DEPRECATE
114 #endif
115
116 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
117 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
118 # define _SCL_SECURE_NO_DEPRECATE
119 #endif
120
121
122
123 /* Python.h has to appear first */
124 #include <Python.h>
125
126 /* -----------------------------------------------------------------------------
127  * swigrun.swg
128  *
129  * This file contains generic CAPI SWIG runtime support for pointer
130  * type checking.
131  * ----------------------------------------------------------------------------- */
132
133 /* This should only be incremented when either the layout of swig_type_info changes,
134    or for whatever reason, the runtime changes incompatibly */
135 #define SWIG_RUNTIME_VERSION "4"
136
137 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
138 #ifdef SWIG_TYPE_TABLE
139 # define SWIG_QUOTE_STRING(x) #x
140 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
141 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
142 #else
143 # define SWIG_TYPE_TABLE_NAME
144 #endif
145
146 /*
147   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
148   creating a static or dynamic library from the swig runtime code.
149   In 99.9% of the cases, swig just needs to declare them as 'static'.
150   
151   But only do this if is strictly necessary, ie, if you have problems
152   with your compiler or so.
153 */
154
155 #ifndef SWIGRUNTIME
156 # define SWIGRUNTIME SWIGINTERN
157 #endif
158
159 #ifndef SWIGRUNTIMEINLINE
160 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
161 #endif
162
163 /*  Generic buffer size */
164 #ifndef SWIG_BUFFER_SIZE
165 # define SWIG_BUFFER_SIZE 1024
166 #endif
167
168 /* Flags for pointer conversions */
169 #define SWIG_POINTER_DISOWN        0x1
170 #define SWIG_CAST_NEW_MEMORY       0x2
171
172 /* Flags for new pointer objects */
173 #define SWIG_POINTER_OWN           0x1
174
175
176 /* 
177    Flags/methods for returning states.
178    
179    The swig conversion methods, as ConvertPtr, return and integer 
180    that tells if the conversion was successful or not. And if not,
181    an error code can be returned (see swigerrors.swg for the codes).
182    
183    Use the following macros/flags to set or process the returning
184    states.
185    
186    In old swig versions, you usually write code as:
187
188      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
189        // success code
190      } else {
191        //fail code
192      }
193
194    Now you can be more explicit as:
195
196     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
197     if (SWIG_IsOK(res)) {
198       // success code
199     } else {
200       // fail code
201     }
202
203    that seems to be the same, but now you can also do
204
205     Type *ptr;
206     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
207     if (SWIG_IsOK(res)) {
208       // success code
209       if (SWIG_IsNewObj(res) {
210         ...
211         delete *ptr;
212       } else {
213         ...
214       }
215     } else {
216       // fail code
217     }
218     
219    I.e., now SWIG_ConvertPtr can return new objects and you can
220    identify the case and take care of the deallocation. Of course that
221    requires also to SWIG_ConvertPtr to return new result values, as
222
223       int SWIG_ConvertPtr(obj, ptr,...) {         
224         if (<obj is ok>) {                             
225           if (<need new object>) {                     
226             *ptr = <ptr to new allocated object>; 
227             return SWIG_NEWOBJ;                
228           } else {                                     
229             *ptr = <ptr to old object>;        
230             return SWIG_OLDOBJ;                
231           }                                    
232         } else {                                       
233           return SWIG_BADOBJ;                  
234         }                                              
235       }
236
237    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
238    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
239    swig errors code.
240
241    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
242    allows to return the 'cast rank', for example, if you have this
243
244        int food(double)
245        int fooi(int);
246
247    and you call
248  
249       food(1)   // cast rank '1'  (1 -> 1.0)
250       fooi(1)   // cast rank '0'
251
252    just use the SWIG_AddCast()/SWIG_CheckState()
253
254
255  */
256 #define SWIG_OK                    (0) 
257 #define SWIG_ERROR                 (-1)
258 #define SWIG_IsOK(r)               (r >= 0)
259 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
260
261 /* The CastRankLimit says how many bits are used for the cast rank */
262 #define SWIG_CASTRANKLIMIT         (1 << 8)
263 /* The NewMask denotes the object was created (using new/malloc) */
264 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
265 /* The TmpMask is for in/out typemaps that use temporal objects */
266 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
267 /* Simple returning values */
268 #define SWIG_BADOBJ                (SWIG_ERROR)
269 #define SWIG_OLDOBJ                (SWIG_OK)
270 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
271 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
272 /* Check, add and del mask methods */
273 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
274 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
275 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
276 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
277 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
278 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
279
280
281 /* Cast-Rank Mode */
282 #if defined(SWIG_CASTRANK_MODE)
283 #  ifndef SWIG_TypeRank
284 #    define SWIG_TypeRank             unsigned long
285 #  endif
286 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
287 #    define SWIG_MAXCASTRANK          (2)
288 #  endif
289 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
290 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
291 SWIGINTERNINLINE int SWIG_AddCast(int r) { 
292   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
293 }
294 SWIGINTERNINLINE int SWIG_CheckState(int r) { 
295   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
296 }
297 #else /* no cast-rank mode */
298 #  define SWIG_AddCast
299 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
300 #endif
301
302
303
304
305 #include <string.h>
306
307 #ifdef __cplusplus
308 extern "C" {
309 #endif
310
311 typedef void *(*swig_converter_func)(void *, int *);
312 typedef struct swig_type_info *(*swig_dycast_func)(void **);
313
314 /* Structure to store information on one type */
315 typedef struct swig_type_info {
316   const char             *name;                 /* mangled name of this type */
317   const char             *str;                  /* human readable name of this type */
318   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
319   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
320   void                   *clientdata;           /* language specific type data */
321   int                    owndata;               /* flag if the structure owns the clientdata */
322 } swig_type_info;
323
324 /* Structure to store a type and conversion function used for casting */
325 typedef struct swig_cast_info {
326   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
327   swig_converter_func     converter;            /* function to cast the void pointers */
328   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
329   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
330 } swig_cast_info;
331
332 /* Structure used to store module information
333  * Each module generates one structure like this, and the runtime collects
334  * all of these structures and stores them in a circularly linked list.*/
335 typedef struct swig_module_info {
336   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
337   size_t                 size;                  /* Number of types in this module */
338   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
339   swig_type_info         **type_initial;        /* Array of initially generated type structures */
340   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
341   void                    *clientdata;          /* Language specific module data */
342 } swig_module_info;
343
344 /* 
345   Compare two type names skipping the space characters, therefore
346   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
347
348   Return 0 when the two name types are equivalent, as in
349   strncmp, but skipping ' '.
350 */
351 SWIGRUNTIME int
352 SWIG_TypeNameComp(const char *f1, const char *l1,
353                   const char *f2, const char *l2) {
354   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
355     while ((*f1 == ' ') && (f1 != l1)) ++f1;
356     while ((*f2 == ' ') && (f2 != l2)) ++f2;
357     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
358   }
359   return (int)((l1 - f1) - (l2 - f2));
360 }
361
362 /*
363   Check type equivalence in a name list like <name1>|<name2>|...
364   Return 0 if not equal, 1 if equal
365 */
366 SWIGRUNTIME int
367 SWIG_TypeEquiv(const char *nb, const char *tb) {
368   int equiv = 0;
369   const char* te = tb + strlen(tb);
370   const char* ne = nb;
371   while (!equiv && *ne) {
372     for (nb = ne; *ne; ++ne) {
373       if (*ne == '|') break;
374     }
375     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
376     if (*ne) ++ne;
377   }
378   return equiv;
379 }
380
381 /*
382   Check type equivalence in a name list like <name1>|<name2>|...
383   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
384 */
385 SWIGRUNTIME int
386 SWIG_TypeCompare(const char *nb, const char *tb) {
387   int equiv = 0;
388   const char* te = tb + strlen(tb);
389   const char* ne = nb;
390   while (!equiv && *ne) {
391     for (nb = ne; *ne; ++ne) {
392       if (*ne == '|') break;
393     }
394     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
395     if (*ne) ++ne;
396   }
397   return equiv;
398 }
399
400
401 /* think of this as a c++ template<> or a scheme macro */
402 #define SWIG_TypeCheck_Template(comparison, ty)         \
403   if (ty) {                                             \
404     swig_cast_info *iter = ty->cast;                    \
405     while (iter) {                                      \
406       if (comparison) {                                 \
407         if (iter == ty->cast) return iter;              \
408         /* Move iter to the top of the linked list */   \
409         iter->prev->next = iter->next;                  \
410         if (iter->next)                                 \
411           iter->next->prev = iter->prev;                \
412         iter->next = ty->cast;                          \
413         iter->prev = 0;                                 \
414         if (ty->cast) ty->cast->prev = iter;            \
415         ty->cast = iter;                                \
416         return iter;                                    \
417       }                                                 \
418       iter = iter->next;                                \
419     }                                                   \
420   }                                                     \
421   return 0
422
423 /*
424   Check the typename
425 */
426 SWIGRUNTIME swig_cast_info *
427 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
428   SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
429 }
430
431 /* Same as previous function, except strcmp is replaced with a pointer comparison */
432 SWIGRUNTIME swig_cast_info *
433 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
434   SWIG_TypeCheck_Template(iter->type == from, into);
435 }
436
437 /*
438   Cast a pointer up an inheritance hierarchy
439 */
440 SWIGRUNTIMEINLINE void *
441 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
442   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
443 }
444
445 /* 
446    Dynamic pointer casting. Down an inheritance hierarchy
447 */
448 SWIGRUNTIME swig_type_info *
449 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
450   swig_type_info *lastty = ty;
451   if (!ty || !ty->dcast) return ty;
452   while (ty && (ty->dcast)) {
453     ty = (*ty->dcast)(ptr);
454     if (ty) lastty = ty;
455   }
456   return lastty;
457 }
458
459 /*
460   Return the name associated with this type
461 */
462 SWIGRUNTIMEINLINE const char *
463 SWIG_TypeName(const swig_type_info *ty) {
464   return ty->name;
465 }
466
467 /*
468   Return the pretty name associated with this type,
469   that is an unmangled type name in a form presentable to the user.
470 */
471 SWIGRUNTIME const char *
472 SWIG_TypePrettyName(const swig_type_info *type) {
473   /* The "str" field contains the equivalent pretty names of the
474      type, separated by vertical-bar characters.  We choose
475      to print the last name, as it is often (?) the most
476      specific. */
477   if (!type) return NULL;
478   if (type->str != NULL) {
479     const char *last_name = type->str;
480     const char *s;
481     for (s = type->str; *s; s++)
482       if (*s == '|') last_name = s+1;
483     return last_name;
484   }
485   else
486     return type->name;
487 }
488
489 /* 
490    Set the clientdata field for a type
491 */
492 SWIGRUNTIME void
493 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
494   swig_cast_info *cast = ti->cast;
495   /* if (ti->clientdata == clientdata) return; */
496   ti->clientdata = clientdata;
497   
498   while (cast) {
499     if (!cast->converter) {
500       swig_type_info *tc = cast->type;
501       if (!tc->clientdata) {
502         SWIG_TypeClientData(tc, clientdata);
503       }
504     }    
505     cast = cast->next;
506   }
507 }
508 SWIGRUNTIME void
509 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
510   SWIG_TypeClientData(ti, clientdata);
511   ti->owndata = 1;
512 }
513   
514 /*
515   Search for a swig_type_info structure only by mangled name
516   Search is a O(log #types)
517   
518   We start searching at module start, and finish searching when start == end.  
519   Note: if start == end at the beginning of the function, we go all the way around
520   the circular list.
521 */
522 SWIGRUNTIME swig_type_info *
523 SWIG_MangledTypeQueryModule(swig_module_info *start, 
524                             swig_module_info *end, 
525                             const char *name) {
526   swig_module_info *iter = start;
527   do {
528     if (iter->size) {
529       register size_t l = 0;
530       register size_t r = iter->size - 1;
531       do {
532         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
533         register size_t i = (l + r) >> 1; 
534         const char *iname = iter->types[i]->name;
535         if (iname) {
536           register int compare = strcmp(name, iname);
537           if (compare == 0) {       
538             return iter->types[i];
539           } else if (compare < 0) {
540             if (i) {
541               r = i - 1;
542             } else {
543               break;
544             }
545           } else if (compare > 0) {
546             l = i + 1;
547           }
548         } else {
549           break; /* should never happen */
550         }
551       } while (l <= r);
552     }
553     iter = iter->next;
554   } while (iter != end);
555   return 0;
556 }
557
558 /*
559   Search for a swig_type_info structure for either a mangled name or a human readable name.
560   It first searches the mangled names of the types, which is a O(log #types)
561   If a type is not found it then searches the human readable names, which is O(#types).
562   
563   We start searching at module start, and finish searching when start == end.  
564   Note: if start == end at the beginning of the function, we go all the way around
565   the circular list.
566 */
567 SWIGRUNTIME swig_type_info *
568 SWIG_TypeQueryModule(swig_module_info *start, 
569                      swig_module_info *end, 
570                      const char *name) {
571   /* STEP 1: Search the name field using binary search */
572   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
573   if (ret) {
574     return ret;
575   } else {
576     /* STEP 2: If the type hasn't been found, do a complete search
577        of the str field (the human readable name) */
578     swig_module_info *iter = start;
579     do {
580       register size_t i = 0;
581       for (; i < iter->size; ++i) {
582         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
583           return iter->types[i];
584       }
585       iter = iter->next;
586     } while (iter != end);
587   }
588   
589   /* neither found a match */
590   return 0;
591 }
592
593 /* 
594    Pack binary data into a string
595 */
596 SWIGRUNTIME char *
597 SWIG_PackData(char *c, void *ptr, size_t sz) {
598   static const char hex[17] = "0123456789abcdef";
599   register const unsigned char *u = (unsigned char *) ptr;
600   register const unsigned char *eu =  u + sz;
601   for (; u != eu; ++u) {
602     register unsigned char uu = *u;
603     *(c++) = hex[(uu & 0xf0) >> 4];
604     *(c++) = hex[uu & 0xf];
605   }
606   return c;
607 }
608
609 /* 
610    Unpack binary data from a string
611 */
612 SWIGRUNTIME const char *
613 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
614   register unsigned char *u = (unsigned char *) ptr;
615   register const unsigned char *eu = u + sz;
616   for (; u != eu; ++u) {
617     register char d = *(c++);
618     register unsigned char uu;
619     if ((d >= '0') && (d <= '9'))
620       uu = ((d - '0') << 4);
621     else if ((d >= 'a') && (d <= 'f'))
622       uu = ((d - ('a'-10)) << 4);
623     else 
624       return (char *) 0;
625     d = *(c++);
626     if ((d >= '0') && (d <= '9'))
627       uu |= (d - '0');
628     else if ((d >= 'a') && (d <= 'f'))
629       uu |= (d - ('a'-10));
630     else 
631       return (char *) 0;
632     *u = uu;
633   }
634   return c;
635 }
636
637 /* 
638    Pack 'void *' into a string buffer.
639 */
640 SWIGRUNTIME char *
641 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
642   char *r = buff;
643   if ((2*sizeof(void *) + 2) > bsz) return 0;
644   *(r++) = '_';
645   r = SWIG_PackData(r,&ptr,sizeof(void *));
646   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
647   strcpy(r,name);
648   return buff;
649 }
650
651 SWIGRUNTIME const char *
652 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
653   if (*c != '_') {
654     if (strcmp(c,"NULL") == 0) {
655       *ptr = (void *) 0;
656       return name;
657     } else {
658       return 0;
659     }
660   }
661   return SWIG_UnpackData(++c,ptr,sizeof(void *));
662 }
663
664 SWIGRUNTIME char *
665 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
666   char *r = buff;
667   size_t lname = (name ? strlen(name) : 0);
668   if ((2*sz + 2 + lname) > bsz) return 0;
669   *(r++) = '_';
670   r = SWIG_PackData(r,ptr,sz);
671   if (lname) {
672     strncpy(r,name,lname+1);
673   } else {
674     *r = 0;
675   }
676   return buff;
677 }
678
679 SWIGRUNTIME const char *
680 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
681   if (*c != '_') {
682     if (strcmp(c,"NULL") == 0) {
683       memset(ptr,0,sz);
684       return name;
685     } else {
686       return 0;
687     }
688   }
689   return SWIG_UnpackData(++c,ptr,sz);
690 }
691
692 #ifdef __cplusplus
693 }
694 #endif
695
696 /*  Errors in SWIG */
697 #define  SWIG_UnknownError         -1 
698 #define  SWIG_IOError              -2 
699 #define  SWIG_RuntimeError         -3 
700 #define  SWIG_IndexError           -4 
701 #define  SWIG_TypeError            -5 
702 #define  SWIG_DivisionByZero       -6 
703 #define  SWIG_OverflowError        -7 
704 #define  SWIG_SyntaxError          -8 
705 #define  SWIG_ValueError           -9 
706 #define  SWIG_SystemError          -10
707 #define  SWIG_AttributeError       -11
708 #define  SWIG_MemoryError          -12 
709 #define  SWIG_NullReferenceError   -13
710
711
712
713
714 /* Add PyOS_snprintf for old Pythons */
715 #if PY_VERSION_HEX < 0x02020000
716 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
717 #  define PyOS_snprintf _snprintf
718 # else
719 #  define PyOS_snprintf snprintf
720 # endif
721 #endif
722
723 /* A crude PyString_FromFormat implementation for old Pythons */
724 #if PY_VERSION_HEX < 0x02020000
725
726 #ifndef SWIG_PYBUFFER_SIZE
727 # define SWIG_PYBUFFER_SIZE 1024
728 #endif
729
730 static PyObject *
731 PyString_FromFormat(const char *fmt, ...) {
732   va_list ap;
733   char buf[SWIG_PYBUFFER_SIZE * 2];
734   int res;
735   va_start(ap, fmt);
736   res = vsnprintf(buf, sizeof(buf), fmt, ap);
737   va_end(ap);
738   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
739 }
740 #endif
741
742 /* Add PyObject_Del for old Pythons */
743 #if PY_VERSION_HEX < 0x01060000
744 # define PyObject_Del(op) PyMem_DEL((op))
745 #endif
746 #ifndef PyObject_DEL
747 # define PyObject_DEL PyObject_Del
748 #endif
749
750 /* A crude PyExc_StopIteration exception for old Pythons */
751 #if PY_VERSION_HEX < 0x02020000
752 # ifndef PyExc_StopIteration
753 #  define PyExc_StopIteration PyExc_RuntimeError
754 # endif
755 # ifndef PyObject_GenericGetAttr
756 #  define PyObject_GenericGetAttr 0
757 # endif
758 #endif
759 /* Py_NotImplemented is defined in 2.1 and up. */
760 #if PY_VERSION_HEX < 0x02010000
761 # ifndef Py_NotImplemented
762 #  define Py_NotImplemented PyExc_RuntimeError
763 # endif
764 #endif
765
766
767 /* A crude PyString_AsStringAndSize implementation for old Pythons */
768 #if PY_VERSION_HEX < 0x02010000
769 # ifndef PyString_AsStringAndSize
770 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
771 # endif
772 #endif
773
774 /* PySequence_Size for old Pythons */
775 #if PY_VERSION_HEX < 0x02000000
776 # ifndef PySequence_Size
777 #  define PySequence_Size PySequence_Length
778 # endif
779 #endif
780
781
782 /* PyBool_FromLong for old Pythons */
783 #if PY_VERSION_HEX < 0x02030000
784 static
785 PyObject *PyBool_FromLong(long ok)
786 {
787   PyObject *result = ok ? Py_True : Py_False;
788   Py_INCREF(result);
789   return result;
790 }
791 #endif
792
793 /* Py_ssize_t for old Pythons */
794 /* This code is as recommended by: */
795 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
796 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
797 typedef int Py_ssize_t;
798 # define PY_SSIZE_T_MAX INT_MAX
799 # define PY_SSIZE_T_MIN INT_MIN
800 #endif
801
802 /* -----------------------------------------------------------------------------
803  * error manipulation
804  * ----------------------------------------------------------------------------- */
805
806 SWIGRUNTIME PyObject*
807 SWIG_Python_ErrorType(int code) {
808   PyObject* type = 0;
809   switch(code) {
810   case SWIG_MemoryError:
811     type = PyExc_MemoryError;
812     break;
813   case SWIG_IOError:
814     type = PyExc_IOError;
815     break;
816   case SWIG_RuntimeError:
817     type = PyExc_RuntimeError;
818     break;
819   case SWIG_IndexError:
820     type = PyExc_IndexError;
821     break;
822   case SWIG_TypeError:
823     type = PyExc_TypeError;
824     break;
825   case SWIG_DivisionByZero:
826     type = PyExc_ZeroDivisionError;
827     break;
828   case SWIG_OverflowError:
829     type = PyExc_OverflowError;
830     break;
831   case SWIG_SyntaxError:
832     type = PyExc_SyntaxError;
833     break;
834   case SWIG_ValueError:
835     type = PyExc_ValueError;
836     break;
837   case SWIG_SystemError:
838     type = PyExc_SystemError;
839     break;
840   case SWIG_AttributeError:
841     type = PyExc_AttributeError;
842     break;
843   default:
844     type = PyExc_RuntimeError;
845   }
846   return type;
847 }
848
849
850 SWIGRUNTIME void
851 SWIG_Python_AddErrorMsg(const char* mesg)
852 {
853   PyObject *type = 0;
854   PyObject *value = 0;
855   PyObject *traceback = 0;
856
857   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
858   if (value) {
859     PyObject *old_str = PyObject_Str(value);
860     PyErr_Clear();
861     Py_XINCREF(type);
862     PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
863     Py_DECREF(old_str);
864     Py_DECREF(value);
865   } else {
866     PyErr_SetString(PyExc_RuntimeError, mesg);
867   }
868 }
869
870
871
872 #if defined(SWIG_PYTHON_NO_THREADS)
873 #  if defined(SWIG_PYTHON_THREADS)
874 #    undef SWIG_PYTHON_THREADS
875 #  endif
876 #endif
877 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
878 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
879 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
880 #      define SWIG_PYTHON_USE_GIL
881 #    endif
882 #  endif
883 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
884 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
885 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
886 #    endif
887 #    ifdef __cplusplus /* C++ code */
888        class SWIG_Python_Thread_Block {
889          bool status;
890          PyGILState_STATE state;
891        public:
892          void end() { if (status) { PyGILState_Release(state); status = false;} }
893          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
894          ~SWIG_Python_Thread_Block() { end(); }
895        };
896        class SWIG_Python_Thread_Allow {
897          bool status;
898          PyThreadState *save;
899        public:
900          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
901          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
902          ~SWIG_Python_Thread_Allow() { end(); }
903        };
904 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
905 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
906 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
907 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
908 #    else /* C code */
909 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
910 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
911 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
912 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
913 #    endif
914 #  else /* Old thread way, not implemented, user must provide it */
915 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
916 #      define SWIG_PYTHON_INITIALIZE_THREADS
917 #    endif
918 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
919 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
920 #    endif
921 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
922 #      define SWIG_PYTHON_THREAD_END_BLOCK
923 #    endif
924 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
925 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
926 #    endif
927 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
928 #      define SWIG_PYTHON_THREAD_END_ALLOW
929 #    endif
930 #  endif
931 #else /* No thread support */
932 #  define SWIG_PYTHON_INITIALIZE_THREADS
933 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
934 #  define SWIG_PYTHON_THREAD_END_BLOCK
935 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
936 #  define SWIG_PYTHON_THREAD_END_ALLOW
937 #endif
938
939 /* -----------------------------------------------------------------------------
940  * Python API portion that goes into the runtime
941  * ----------------------------------------------------------------------------- */
942
943 #ifdef __cplusplus
944 extern "C" {
945 #if 0
946 } /* cc-mode */
947 #endif
948 #endif
949
950 /* -----------------------------------------------------------------------------
951  * Constant declarations
952  * ----------------------------------------------------------------------------- */
953
954 /* Constant Types */
955 #define SWIG_PY_POINTER 4
956 #define SWIG_PY_BINARY  5
957
958 /* Constant information structure */
959 typedef struct swig_const_info {
960   int type;
961   char *name;
962   long lvalue;
963   double dvalue;
964   void   *pvalue;
965   swig_type_info **ptype;
966 } swig_const_info;
967
968 #ifdef __cplusplus
969 #if 0
970 { /* cc-mode */
971 #endif
972 }
973 #endif
974
975
976 /* -----------------------------------------------------------------------------
977  * See the LICENSE file for information on copyright, usage and redistribution
978  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
979  *
980  * pyrun.swg
981  *
982  * This file contains the runtime support for Python modules
983  * and includes code for managing global variables and pointer
984  * type checking.
985  *
986  * ----------------------------------------------------------------------------- */
987
988 /* Common SWIG API */
989
990 /* for raw pointers */
991 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
992 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
993 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
994 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
995 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
996 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
997 #define swig_owntype                                    int
998
999 /* for raw packed data */
1000 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1001 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1002
1003 /* for class or struct pointers */
1004 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
1005 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
1006
1007 /* for C or C++ function pointers */
1008 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1009 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
1010
1011 /* for C++ member pointers, ie, member methods */
1012 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1013 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1014
1015
1016 /* Runtime API */
1017
1018 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1019 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1020 #define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
1021
1022 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
1023 #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg                            
1024 #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)                        
1025 #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
1026 #define SWIG_fail                                       goto fail                                          
1027
1028
1029 /* Runtime API implementation */
1030
1031 /* Error manipulation */
1032
1033 SWIGINTERN void 
1034 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1035   SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
1036   PyErr_SetObject(errtype, obj);
1037   Py_DECREF(obj);
1038   SWIG_PYTHON_THREAD_END_BLOCK;
1039 }
1040
1041 SWIGINTERN void 
1042 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1043   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1044   PyErr_SetString(errtype, (char *) msg);
1045   SWIG_PYTHON_THREAD_END_BLOCK;
1046 }
1047
1048 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1049
1050 /* Set a constant value */
1051
1052 SWIGINTERN void
1053 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
1054   PyDict_SetItemString(d, (char*) name, obj);
1055   Py_DECREF(obj);                            
1056 }
1057
1058 /* Append a value to the result obj */
1059
1060 SWIGINTERN PyObject*
1061 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1062 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1063   if (!result) {
1064     result = obj;
1065   } else if (result == Py_None) {
1066     Py_DECREF(result);
1067     result = obj;
1068   } else {
1069     if (!PyList_Check(result)) {
1070       PyObject *o2 = result;
1071       result = PyList_New(1);
1072       PyList_SetItem(result, 0, o2);
1073     }
1074     PyList_Append(result,obj);
1075     Py_DECREF(obj);
1076   }
1077   return result;
1078 #else
1079   PyObject*   o2;
1080   PyObject*   o3;
1081   if (!result) {
1082     result = obj;
1083   } else if (result == Py_None) {
1084     Py_DECREF(result);
1085     result = obj;
1086   } else {
1087     if (!PyTuple_Check(result)) {
1088       o2 = result;
1089       result = PyTuple_New(1);
1090       PyTuple_SET_ITEM(result, 0, o2);
1091     }
1092     o3 = PyTuple_New(1);
1093     PyTuple_SET_ITEM(o3, 0, obj);
1094     o2 = result;
1095     result = PySequence_Concat(o2, o3);
1096     Py_DECREF(o2);
1097     Py_DECREF(o3);
1098   }
1099   return result;
1100 #endif
1101 }
1102
1103 /* Unpack the argument tuple */
1104
1105 SWIGINTERN int
1106 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1107 {
1108   if (!args) {
1109     if (!min && !max) {
1110       return 1;
1111     } else {
1112       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
1113                    name, (min == max ? "" : "at least "), (int)min);
1114       return 0;
1115     }
1116   }  
1117   if (!PyTuple_Check(args)) {
1118     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1119     return 0;
1120   } else {
1121     register Py_ssize_t l = PyTuple_GET_SIZE(args);
1122     if (l < min) {
1123       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
1124                    name, (min == max ? "" : "at least "), (int)min, (int)l);
1125       return 0;
1126     } else if (l > max) {
1127       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
1128                    name, (min == max ? "" : "at most "), (int)max, (int)l);
1129       return 0;
1130     } else {
1131       register int i;
1132       for (i = 0; i < l; ++i) {
1133         objs[i] = PyTuple_GET_ITEM(args, i);
1134       }
1135       for (; l < max; ++l) {
1136         objs[l] = 0;
1137       }
1138       return i + 1;
1139     }    
1140   }
1141 }
1142
1143 /* A functor is a function object with one single object argument */
1144 #if PY_VERSION_HEX >= 0x02020000
1145 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
1146 #else
1147 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
1148 #endif
1149
1150 /*
1151   Helper for static pointer initialization for both C and C++ code, for example
1152   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1153 */
1154 #ifdef __cplusplus
1155 #define SWIG_STATIC_POINTER(var)  var
1156 #else
1157 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1158 #endif
1159
1160 /* -----------------------------------------------------------------------------
1161  * Pointer declarations
1162  * ----------------------------------------------------------------------------- */
1163
1164 /* Flags for new pointer objects */
1165 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
1166 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1167
1168 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1169
1170 #ifdef __cplusplus
1171 extern "C" {
1172 #if 0
1173 } /* cc-mode */
1174 #endif
1175 #endif
1176
1177 /*  How to access Py_None */
1178 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1179 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
1180 #    ifndef SWIG_PYTHON_BUILD_NONE
1181 #      define SWIG_PYTHON_BUILD_NONE
1182 #    endif
1183 #  endif
1184 #endif
1185
1186 #ifdef SWIG_PYTHON_BUILD_NONE
1187 #  ifdef Py_None
1188 #   undef Py_None
1189 #   define Py_None SWIG_Py_None()
1190 #  endif
1191 SWIGRUNTIMEINLINE PyObject * 
1192 _SWIG_Py_None(void)
1193 {
1194   PyObject *none = Py_BuildValue((char*)"");
1195   Py_DECREF(none);
1196   return none;
1197 }
1198 SWIGRUNTIME PyObject * 
1199 SWIG_Py_None(void)
1200 {
1201   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1202   return none;
1203 }
1204 #endif
1205
1206 /* The python void return value */
1207
1208 SWIGRUNTIMEINLINE PyObject * 
1209 SWIG_Py_Void(void)
1210 {
1211   PyObject *none = Py_None;
1212   Py_INCREF(none);
1213   return none;
1214 }
1215
1216 /* PySwigClientData */
1217
1218 typedef struct {
1219   PyObject *klass;
1220   PyObject *newraw;
1221   PyObject *newargs;
1222   PyObject *destroy;
1223   int delargs;
1224   int implicitconv;
1225 } PySwigClientData;
1226
1227 SWIGRUNTIMEINLINE int 
1228 SWIG_Python_CheckImplicit(swig_type_info *ty)
1229 {
1230   PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1231   return data ? data->implicitconv : 0;
1232 }
1233
1234 SWIGRUNTIMEINLINE PyObject *
1235 SWIG_Python_ExceptionType(swig_type_info *desc) {
1236   PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1237   PyObject *klass = data ? data->klass : 0;
1238   return (klass ? klass : PyExc_RuntimeError);
1239 }
1240
1241
1242 SWIGRUNTIME PySwigClientData * 
1243 PySwigClientData_New(PyObject* obj)
1244 {
1245   if (!obj) {
1246     return 0;
1247   } else {
1248     PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1249     /* the klass element */
1250     data->klass = obj;
1251     Py_INCREF(data->klass);
1252     /* the newraw method and newargs arguments used to create a new raw instance */
1253     if (PyClass_Check(obj)) {
1254       data->newraw = 0;
1255       data->newargs = obj;
1256       Py_INCREF(obj);
1257     } else {
1258 #if (PY_VERSION_HEX < 0x02020000)
1259       data->newraw = 0;
1260 #else
1261       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1262 #endif
1263       if (data->newraw) {
1264         Py_INCREF(data->newraw);
1265         data->newargs = PyTuple_New(1);
1266         PyTuple_SetItem(data->newargs, 0, obj);
1267       } else {
1268         data->newargs = obj;
1269       }
1270       Py_INCREF(data->newargs);
1271     }
1272     /* the destroy method, aka as the C++ delete method */
1273     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1274     if (PyErr_Occurred()) {
1275       PyErr_Clear();
1276       data->destroy = 0;
1277     }
1278     if (data->destroy) {
1279       int flags;
1280       Py_INCREF(data->destroy);
1281       flags = PyCFunction_GET_FLAGS(data->destroy);
1282 #ifdef METH_O
1283       data->delargs = !(flags & (METH_O));
1284 #else
1285       data->delargs = 0;
1286 #endif
1287     } else {
1288       data->delargs = 0;
1289     }
1290     data->implicitconv = 0;
1291     return data;
1292   }
1293 }
1294
1295 SWIGRUNTIME void 
1296 PySwigClientData_Del(PySwigClientData* data)
1297 {
1298   Py_XDECREF(data->newraw);
1299   Py_XDECREF(data->newargs);
1300   Py_XDECREF(data->destroy);
1301 }
1302
1303 /* =============== PySwigObject =====================*/
1304
1305 typedef struct {
1306   PyObject_HEAD
1307   void *ptr;
1308   swig_type_info *ty;
1309   int own;
1310   PyObject *next;
1311 } PySwigObject;
1312
1313 SWIGRUNTIME PyObject *
1314 PySwigObject_long(PySwigObject *v)
1315 {
1316   return PyLong_FromVoidPtr(v->ptr);
1317 }
1318
1319 SWIGRUNTIME PyObject *
1320 PySwigObject_format(const char* fmt, PySwigObject *v)
1321 {
1322   PyObject *res = NULL;
1323   PyObject *args = PyTuple_New(1);
1324   if (args) {
1325     if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1326       PyObject *ofmt = PyString_FromString(fmt);
1327       if (ofmt) {
1328         res = PyString_Format(ofmt,args);
1329         Py_DECREF(ofmt);
1330       }
1331       Py_DECREF(args);
1332     }
1333   }
1334   return res;
1335 }
1336
1337 SWIGRUNTIME PyObject *
1338 PySwigObject_oct(PySwigObject *v)
1339 {
1340   return PySwigObject_format("%o",v);
1341 }
1342
1343 SWIGRUNTIME PyObject *
1344 PySwigObject_hex(PySwigObject *v)
1345 {
1346   return PySwigObject_format("%x",v);
1347 }
1348
1349 SWIGRUNTIME PyObject *
1350 #ifdef METH_NOARGS
1351 PySwigObject_repr(PySwigObject *v)
1352 #else
1353 PySwigObject_repr(PySwigObject *v, PyObject *args)
1354 #endif
1355 {
1356   const char *name = SWIG_TypePrettyName(v->ty);
1357   PyObject *hex = PySwigObject_hex(v);    
1358   PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1359   Py_DECREF(hex);
1360   if (v->next) {
1361 #ifdef METH_NOARGS
1362     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1363 #else
1364     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1365 #endif
1366     PyString_ConcatAndDel(&repr,nrep);
1367   }
1368   return repr;  
1369 }
1370
1371 SWIGRUNTIME int
1372 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1373 {
1374 #ifdef METH_NOARGS
1375   PyObject *repr = PySwigObject_repr(v);
1376 #else
1377   PyObject *repr = PySwigObject_repr(v, NULL);
1378 #endif
1379   if (repr) {
1380     fputs(PyString_AsString(repr), fp);
1381     Py_DECREF(repr);
1382     return 0; 
1383   } else {
1384     return 1; 
1385   }
1386 }
1387
1388 SWIGRUNTIME PyObject *
1389 PySwigObject_str(PySwigObject *v)
1390 {
1391   char result[SWIG_BUFFER_SIZE];
1392   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1393     PyString_FromString(result) : 0;
1394 }
1395
1396 SWIGRUNTIME int
1397 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1398 {
1399   void *i = v->ptr;
1400   void *j = w->ptr;
1401   return (i < j) ? -1 : ((i > j) ? 1 : 0);
1402 }
1403
1404 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1405
1406 SWIGRUNTIME PyTypeObject*
1407 PySwigObject_type(void) {
1408   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1409   return type;
1410 }
1411
1412 SWIGRUNTIMEINLINE int
1413 PySwigObject_Check(PyObject *op) {
1414   return ((op)->ob_type == PySwigObject_type())
1415     || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1416 }
1417
1418 SWIGRUNTIME PyObject *
1419 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1420
1421 SWIGRUNTIME void
1422 PySwigObject_dealloc(PyObject *v)
1423 {
1424   PySwigObject *sobj = (PySwigObject *) v;
1425   PyObject *next = sobj->next;
1426   if (sobj->own == SWIG_POINTER_OWN) {
1427     swig_type_info *ty = sobj->ty;
1428     PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1429     PyObject *destroy = data ? data->destroy : 0;
1430     if (destroy) {
1431       /* destroy is always a VARARGS method */
1432       PyObject *res;
1433       if (data->delargs) {
1434         /* we need to create a temporal object to carry the destroy operation */
1435         PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1436         res = SWIG_Python_CallFunctor(destroy, tmp);
1437         Py_DECREF(tmp);
1438       } else {
1439         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1440         PyObject *mself = PyCFunction_GET_SELF(destroy);
1441         res = ((*meth)(mself, v));
1442       }
1443       Py_XDECREF(res);
1444     } 
1445 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1446     else {
1447       const char *name = SWIG_TypePrettyName(ty);
1448       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1449     }
1450 #endif
1451   } 
1452   Py_XDECREF(next);
1453   PyObject_DEL(v);
1454 }
1455
1456 SWIGRUNTIME PyObject* 
1457 PySwigObject_append(PyObject* v, PyObject* next)
1458 {
1459   PySwigObject *sobj = (PySwigObject *) v;
1460 #ifndef METH_O
1461   PyObject *tmp = 0;
1462   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1463   next = tmp;
1464 #endif
1465   if (!PySwigObject_Check(next)) {
1466     return NULL;
1467   }
1468   sobj->next = next;
1469   Py_INCREF(next);
1470   return SWIG_Py_Void();
1471 }
1472
1473 SWIGRUNTIME PyObject* 
1474 #ifdef METH_NOARGS
1475 PySwigObject_next(PyObject* v)
1476 #else
1477 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1478 #endif
1479 {
1480   PySwigObject *sobj = (PySwigObject *) v;
1481   if (sobj->next) {    
1482     Py_INCREF(sobj->next);
1483     return sobj->next;
1484   } else {
1485     return SWIG_Py_Void();
1486   }
1487 }
1488
1489 SWIGINTERN PyObject*
1490 #ifdef METH_NOARGS
1491 PySwigObject_disown(PyObject *v)
1492 #else
1493 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1494 #endif
1495 {
1496   PySwigObject *sobj = (PySwigObject *)v;
1497   sobj->own = 0;
1498   return SWIG_Py_Void();
1499 }
1500
1501 SWIGINTERN PyObject*
1502 #ifdef METH_NOARGS
1503 PySwigObject_acquire(PyObject *v)
1504 #else
1505 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1506 #endif
1507 {
1508   PySwigObject *sobj = (PySwigObject *)v;
1509   sobj->own = SWIG_POINTER_OWN;
1510   return SWIG_Py_Void();
1511 }
1512
1513 SWIGINTERN PyObject*
1514 PySwigObject_own(PyObject *v, PyObject *args)
1515 {
1516   PyObject *val = 0;
1517 #if (PY_VERSION_HEX < 0x02020000)
1518   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1519 #else
1520   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
1521 #endif
1522     {
1523       return NULL;
1524     } 
1525   else
1526     {
1527       PySwigObject *sobj = (PySwigObject *)v;
1528       PyObject *obj = PyBool_FromLong(sobj->own);
1529       if (val) {
1530 #ifdef METH_NOARGS
1531         if (PyObject_IsTrue(val)) {
1532           PySwigObject_acquire(v);
1533         } else {
1534           PySwigObject_disown(v);
1535         }
1536 #else
1537         if (PyObject_IsTrue(val)) {
1538           PySwigObject_acquire(v,args);
1539         } else {
1540           PySwigObject_disown(v,args);
1541         }
1542 #endif
1543       } 
1544       return obj;
1545     }
1546 }
1547
1548 #ifdef METH_O
1549 static PyMethodDef
1550 swigobject_methods[] = {
1551   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1552   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
1553   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1554   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
1555   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1556   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1557   {0, 0, 0, 0}  
1558 };
1559 #else
1560 static PyMethodDef
1561 swigobject_methods[] = {
1562   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1563   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1564   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1565   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1566   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1567   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1568   {0, 0, 0, 0}  
1569 };
1570 #endif
1571
1572 #if PY_VERSION_HEX < 0x02020000
1573 SWIGINTERN PyObject *
1574 PySwigObject_getattr(PySwigObject *sobj,char *name)
1575 {
1576   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1577 }
1578 #endif
1579
1580 SWIGRUNTIME PyTypeObject*
1581 _PySwigObject_type(void) {
1582   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1583   
1584   static PyNumberMethods PySwigObject_as_number = {
1585     (binaryfunc)0, /*nb_add*/
1586     (binaryfunc)0, /*nb_subtract*/
1587     (binaryfunc)0, /*nb_multiply*/
1588     (binaryfunc)0, /*nb_divide*/
1589     (binaryfunc)0, /*nb_remainder*/
1590     (binaryfunc)0, /*nb_divmod*/
1591     (ternaryfunc)0,/*nb_power*/
1592     (unaryfunc)0,  /*nb_negative*/
1593     (unaryfunc)0,  /*nb_positive*/
1594     (unaryfunc)0,  /*nb_absolute*/
1595     (inquiry)0,    /*nb_nonzero*/
1596     0,             /*nb_invert*/
1597     0,             /*nb_lshift*/
1598     0,             /*nb_rshift*/
1599     0,             /*nb_and*/
1600     0,             /*nb_xor*/
1601     0,             /*nb_or*/
1602     (coercion)0,   /*nb_coerce*/
1603     (unaryfunc)PySwigObject_long, /*nb_int*/
1604     (unaryfunc)PySwigObject_long, /*nb_long*/
1605     (unaryfunc)0,                 /*nb_float*/
1606     (unaryfunc)PySwigObject_oct,  /*nb_oct*/
1607     (unaryfunc)PySwigObject_hex,  /*nb_hex*/
1608 #if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1609     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1610 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1611     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1612 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1613     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1614 #endif
1615   };
1616
1617   static PyTypeObject pyswigobject_type;  
1618   static int type_init = 0;
1619   if (!type_init) {
1620     const PyTypeObject tmp
1621       = {
1622         PyObject_HEAD_INIT(NULL)
1623         0,                                  /* ob_size */
1624         (char *)"PySwigObject",             /* tp_name */
1625         sizeof(PySwigObject),               /* tp_basicsize */
1626         0,                                  /* tp_itemsize */
1627         (destructor)PySwigObject_dealloc,   /* tp_dealloc */
1628         (printfunc)PySwigObject_print,      /* tp_print */
1629 #if PY_VERSION_HEX < 0x02020000
1630         (getattrfunc)PySwigObject_getattr,  /* tp_getattr */ 
1631 #else
1632         (getattrfunc)0,                     /* tp_getattr */ 
1633 #endif
1634         (setattrfunc)0,                     /* tp_setattr */ 
1635         (cmpfunc)PySwigObject_compare,      /* tp_compare */ 
1636         (reprfunc)PySwigObject_repr,        /* tp_repr */    
1637         &PySwigObject_as_number,            /* tp_as_number */
1638         0,                                  /* tp_as_sequence */
1639         0,                                  /* tp_as_mapping */
1640         (hashfunc)0,                        /* tp_hash */
1641         (ternaryfunc)0,                     /* tp_call */
1642         (reprfunc)PySwigObject_str,         /* tp_str */
1643         PyObject_GenericGetAttr,            /* tp_getattro */
1644         0,                                  /* tp_setattro */
1645         0,                                  /* tp_as_buffer */
1646         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1647         swigobject_doc,                     /* tp_doc */        
1648         0,                                  /* tp_traverse */
1649         0,                                  /* tp_clear */
1650         0,                                  /* tp_richcompare */
1651         0,                                  /* tp_weaklistoffset */
1652 #if PY_VERSION_HEX >= 0x02020000
1653         0,                                  /* tp_iter */
1654         0,                                  /* tp_iternext */
1655         swigobject_methods,                 /* tp_methods */ 
1656         0,                                  /* tp_members */
1657         0,                                  /* tp_getset */             
1658         0,                                  /* tp_base */               
1659         0,                                  /* tp_dict */               
1660         0,                                  /* tp_descr_get */          
1661         0,                                  /* tp_descr_set */          
1662         0,                                  /* tp_dictoffset */         
1663         0,                                  /* tp_init */               
1664         0,                                  /* tp_alloc */              
1665         0,                                  /* tp_new */                
1666         0,                                  /* tp_free */          
1667         0,                                  /* tp_is_gc */  
1668         0,                                  /* tp_bases */   
1669         0,                                  /* tp_mro */
1670         0,                                  /* tp_cache */   
1671         0,                                  /* tp_subclasses */
1672         0,                                  /* tp_weaklist */
1673 #endif
1674 #if PY_VERSION_HEX >= 0x02030000
1675         0,                                  /* tp_del */
1676 #endif
1677 #ifdef COUNT_ALLOCS
1678         0,0,0,0                             /* tp_alloc -> tp_next */
1679 #endif
1680       };
1681     pyswigobject_type = tmp;
1682     pyswigobject_type.ob_type = &PyType_Type;
1683     type_init = 1;
1684   }
1685   return &pyswigobject_type;
1686 }
1687
1688 SWIGRUNTIME PyObject *
1689 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1690 {
1691   PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1692   if (sobj) {
1693     sobj->ptr  = ptr;
1694     sobj->ty   = ty;
1695     sobj->own  = own;
1696     sobj->next = 0;
1697   }
1698   return (PyObject *)sobj;
1699 }
1700
1701 /* -----------------------------------------------------------------------------
1702  * Implements a simple Swig Packed type, and use it instead of string
1703  * ----------------------------------------------------------------------------- */
1704
1705 typedef struct {
1706   PyObject_HEAD
1707   void *pack;
1708   swig_type_info *ty;
1709   size_t size;
1710 } PySwigPacked;
1711
1712 SWIGRUNTIME int
1713 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1714 {
1715   char result[SWIG_BUFFER_SIZE];
1716   fputs("<Swig Packed ", fp); 
1717   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1718     fputs("at ", fp); 
1719     fputs(result, fp); 
1720   }
1721   fputs(v->ty->name,fp); 
1722   fputs(">", fp);
1723   return 0; 
1724 }
1725   
1726 SWIGRUNTIME PyObject *
1727 PySwigPacked_repr(PySwigPacked *v)
1728 {
1729   char result[SWIG_BUFFER_SIZE];
1730   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1731     return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1732   } else {
1733     return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1734   }  
1735 }
1736
1737 SWIGRUNTIME PyObject *
1738 PySwigPacked_str(PySwigPacked *v)
1739 {
1740   char result[SWIG_BUFFER_SIZE];
1741   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1742     return PyString_FromFormat("%s%s", result, v->ty->name);
1743   } else {
1744     return PyString_FromString(v->ty->name);
1745   }  
1746 }
1747
1748 SWIGRUNTIME int
1749 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1750 {
1751   size_t i = v->size;
1752   size_t j = w->size;
1753   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1754   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1755 }
1756
1757 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1758
1759 SWIGRUNTIME PyTypeObject*
1760 PySwigPacked_type(void) {
1761   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1762   return type;
1763 }
1764
1765 SWIGRUNTIMEINLINE int
1766 PySwigPacked_Check(PyObject *op) {
1767   return ((op)->ob_type == _PySwigPacked_type()) 
1768     || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1769 }
1770
1771 SWIGRUNTIME void
1772 PySwigPacked_dealloc(PyObject *v)
1773 {
1774   if (PySwigPacked_Check(v)) {
1775     PySwigPacked *sobj = (PySwigPacked *) v;
1776     free(sobj->pack);
1777   }
1778   PyObject_DEL(v);
1779 }
1780
1781 SWIGRUNTIME PyTypeObject*
1782 _PySwigPacked_type(void) {
1783   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1784   static PyTypeObject pyswigpacked_type;
1785   static int type_init = 0;  
1786   if (!type_init) {
1787     const PyTypeObject tmp
1788       = {
1789         PyObject_HEAD_INIT(NULL)
1790         0,                                  /* ob_size */       
1791         (char *)"PySwigPacked",             /* tp_name */       
1792         sizeof(PySwigPacked),               /* tp_basicsize */  
1793         0,                                  /* tp_itemsize */   
1794         (destructor)PySwigPacked_dealloc,   /* tp_dealloc */    
1795         (printfunc)PySwigPacked_print,      /* tp_print */      
1796         (getattrfunc)0,                     /* tp_getattr */    
1797         (setattrfunc)0,                     /* tp_setattr */    
1798         (cmpfunc)PySwigPacked_compare,      /* tp_compare */    
1799         (reprfunc)PySwigPacked_repr,        /* tp_repr */       
1800         0,                                  /* tp_as_number */  
1801         0,                                  /* tp_as_sequence */
1802         0,                                  /* tp_as_mapping */ 
1803         (hashfunc)0,                        /* tp_hash */       
1804         (ternaryfunc)0,                     /* tp_call */       
1805         (reprfunc)PySwigPacked_str,         /* tp_str */        
1806         PyObject_GenericGetAttr,            /* tp_getattro */
1807         0,                                  /* tp_setattro */
1808         0,                                  /* tp_as_buffer */
1809         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1810         swigpacked_doc,                     /* tp_doc */
1811         0,                                  /* tp_traverse */
1812         0,                                  /* tp_clear */
1813         0,                                  /* tp_richcompare */
1814         0,                                  /* tp_weaklistoffset */
1815 #if PY_VERSION_HEX >= 0x02020000
1816         0,                                  /* tp_iter */
1817         0,                                  /* tp_iternext */
1818         0,                                  /* tp_methods */ 
1819         0,                                  /* tp_members */
1820         0,                                  /* tp_getset */             
1821         0,                                  /* tp_base */               
1822         0,                                  /* tp_dict */               
1823         0,                                  /* tp_descr_get */          
1824         0,                                  /* tp_descr_set */          
1825         0,                                  /* tp_dictoffset */         
1826         0,                                  /* tp_init */               
1827         0,                                  /* tp_alloc */              
1828         0,                                  /* tp_new */                
1829         0,                                  /* tp_free */          
1830         0,                                  /* tp_is_gc */  
1831         0,                                  /* tp_bases */   
1832         0,                                  /* tp_mro */
1833         0,                                  /* tp_cache */   
1834         0,                                  /* tp_subclasses */
1835         0,                                  /* tp_weaklist */
1836 #endif
1837 #if PY_VERSION_HEX >= 0x02030000
1838         0,                                  /* tp_del */
1839 #endif
1840 #ifdef COUNT_ALLOCS
1841         0,0,0,0                             /* tp_alloc -> tp_next */
1842 #endif
1843       };
1844     pyswigpacked_type = tmp;
1845     pyswigpacked_type.ob_type = &PyType_Type;
1846     type_init = 1;
1847   }
1848   return &pyswigpacked_type;
1849 }
1850
1851 SWIGRUNTIME PyObject *
1852 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1853 {
1854   PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1855   if (sobj) {
1856     void *pack = malloc(size);
1857     if (pack) {
1858       memcpy(pack, ptr, size);
1859       sobj->pack = pack;
1860       sobj->ty   = ty;
1861       sobj->size = size;
1862     } else {
1863       PyObject_DEL((PyObject *) sobj);
1864       sobj = 0;
1865     }
1866   }
1867   return (PyObject *) sobj;
1868 }
1869
1870 SWIGRUNTIME swig_type_info *
1871 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1872 {
1873   if (PySwigPacked_Check(obj)) {
1874     PySwigPacked *sobj = (PySwigPacked *)obj;
1875     if (sobj->size != size) return 0;
1876     memcpy(ptr, sobj->pack, size);
1877     return sobj->ty;
1878   } else {
1879     return 0;
1880   }
1881 }
1882
1883 /* -----------------------------------------------------------------------------
1884  * pointers/data manipulation
1885  * ----------------------------------------------------------------------------- */
1886
1887 SWIGRUNTIMEINLINE PyObject *
1888 _SWIG_This(void)
1889 {
1890   return PyString_FromString("this");
1891 }
1892
1893 SWIGRUNTIME PyObject *
1894 SWIG_This(void)
1895 {
1896   static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1897   return swig_this;
1898 }
1899
1900 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1901
1902 SWIGRUNTIME PySwigObject *
1903 SWIG_Python_GetSwigThis(PyObject *pyobj) 
1904 {
1905   if (PySwigObject_Check(pyobj)) {
1906     return (PySwigObject *) pyobj;
1907   } else {
1908     PyObject *obj = 0;
1909 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1910     if (PyInstance_Check(pyobj)) {
1911       obj = _PyInstance_Lookup(pyobj, SWIG_This());      
1912     } else {
1913       PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1914       if (dictptr != NULL) {
1915         PyObject *dict = *dictptr;
1916         obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1917       } else {
1918 #ifdef PyWeakref_CheckProxy
1919         if (PyWeakref_CheckProxy(pyobj)) {
1920           PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1921           return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1922         }
1923 #endif
1924         obj = PyObject_GetAttr(pyobj,SWIG_This());
1925         if (obj) {
1926           Py_DECREF(obj);
1927         } else {
1928           if (PyErr_Occurred()) PyErr_Clear();
1929           return 0;
1930         }
1931       }
1932     }
1933 #else
1934     obj = PyObject_GetAttr(pyobj,SWIG_This());
1935     if (obj) {
1936       Py_DECREF(obj);
1937     } else {
1938       if (PyErr_Occurred()) PyErr_Clear();
1939       return 0;
1940     }
1941 #endif
1942     if (obj && !PySwigObject_Check(obj)) {
1943       /* a PyObject is called 'this', try to get the 'real this'
1944          PySwigObject from it */ 
1945       return SWIG_Python_GetSwigThis(obj);
1946     }
1947     return (PySwigObject *)obj;
1948   }
1949 }
1950
1951 /* Acquire a pointer value */
1952
1953 SWIGRUNTIME int
1954 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1955   if (own == SWIG_POINTER_OWN) {
1956     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1957     if (sobj) {
1958       int oldown = sobj->own;
1959       sobj->own = own;
1960       return oldown;
1961     }
1962   }
1963   return 0;
1964 }
1965
1966 /* Convert a pointer value */
1967
1968 SWIGRUNTIME int
1969 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1970   if (!obj) return SWIG_ERROR;
1971   if (obj == Py_None) {
1972     if (ptr) *ptr = 0;
1973     return SWIG_OK;
1974   } else {
1975     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1976     if (own)
1977       *own = 0;
1978     while (sobj) {
1979       void *vptr = sobj->ptr;
1980       if (ty) {
1981         swig_type_info *to = sobj->ty;
1982         if (to == ty) {
1983           /* no type cast needed */
1984           if (ptr) *ptr = vptr;
1985           break;
1986         } else {
1987           swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1988           if (!tc) {
1989             sobj = (PySwigObject *)sobj->next;
1990           } else {
1991             if (ptr) {
1992               int newmemory = 0;
1993               *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
1994               if (newmemory == SWIG_CAST_NEW_MEMORY) {
1995                 assert(own);
1996                 if (own)
1997                   *own = *own | SWIG_CAST_NEW_MEMORY;
1998               }
1999             }
2000             break;
2001           }
2002         }
2003       } else {
2004         if (ptr) *ptr = vptr;
2005         break;
2006       }
2007     }
2008     if (sobj) {
2009       if (own)
2010         *own = *own | sobj->own;
2011       if (flags & SWIG_POINTER_DISOWN) {
2012         sobj->own = 0;
2013       }
2014       return SWIG_OK;
2015     } else {
2016       int res = SWIG_ERROR;
2017       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2018         PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2019         if (data && !data->implicitconv) {
2020           PyObject *klass = data->klass;
2021           if (klass) {
2022             PyObject *impconv;
2023             data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2024             impconv = SWIG_Python_CallFunctor(klass, obj);
2025             data->implicitconv = 0;
2026             if (PyErr_Occurred()) {
2027               PyErr_Clear();
2028               impconv = 0;
2029             }
2030             if (impconv) {
2031               PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2032               if (iobj) {
2033                 void *vptr;
2034                 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2035                 if (SWIG_IsOK(res)) {
2036                   if (ptr) {
2037                     *ptr = vptr;
2038                     /* transfer the ownership to 'ptr' */
2039                     iobj->own = 0;
2040                     res = SWIG_AddCast(res);
2041                     res = SWIG_AddNewMask(res);
2042                   } else {
2043                     res = SWIG_AddCast(res);                
2044                   }
2045                 }
2046               }
2047               Py_DECREF(impconv);
2048             }
2049           }
2050         }
2051       }
2052       return res;
2053     }
2054   }
2055 }
2056
2057 /* Convert a function ptr value */
2058
2059 SWIGRUNTIME int
2060 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2061   if (!PyCFunction_Check(obj)) {
2062     return SWIG_ConvertPtr(obj, ptr, ty, 0);
2063   } else {
2064     void *vptr = 0;
2065     
2066     /* here we get the method pointer for callbacks */
2067     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2068     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2069     if (desc) {
2070       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2071       if (!desc) return SWIG_ERROR;
2072     }
2073     if (ty) {
2074       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2075       if (tc) {
2076         int newmemory = 0;
2077         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2078         assert(!newmemory); /* newmemory handling not yet implemented */
2079       } else {
2080         return SWIG_ERROR;
2081       }
2082     } else {
2083       *ptr = vptr;
2084     }
2085     return SWIG_OK;
2086   }
2087 }
2088
2089 /* Convert a packed value value */
2090
2091 SWIGRUNTIME int
2092 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2093   swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2094   if (!to) return SWIG_ERROR;
2095   if (ty) {
2096     if (to != ty) {
2097       /* check type cast? */
2098       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2099       if (!tc) return SWIG_ERROR;
2100     }
2101   }
2102   return SWIG_OK;
2103 }  
2104
2105 /* -----------------------------------------------------------------------------
2106  * Create a new pointer object
2107  * ----------------------------------------------------------------------------- */
2108
2109 /*
2110   Create a new instance object, whitout calling __init__, and set the
2111   'this' attribute.
2112 */
2113
2114 SWIGRUNTIME PyObject* 
2115 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2116 {
2117 #if (PY_VERSION_HEX >= 0x02020000)
2118   PyObject *inst = 0;
2119   PyObject *newraw = data->newraw;
2120   if (newraw) {
2121     inst = PyObject_Call(newraw, data->newargs, NULL);
2122     if (inst) {
2123 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2124       PyObject **dictptr = _PyObject_GetDictPtr(inst);
2125       if (dictptr != NULL) {
2126         PyObject *dict = *dictptr;
2127         if (dict == NULL) {
2128           dict = PyDict_New();
2129           *dictptr = dict;
2130           PyDict_SetItem(dict, SWIG_This(), swig_this);
2131         }
2132       }
2133 #else
2134       PyObject *key = SWIG_This();
2135       PyObject_SetAttr(inst, key, swig_this);
2136 #endif
2137     }
2138   } else {
2139     PyObject *dict = PyDict_New();
2140     PyDict_SetItem(dict, SWIG_This(), swig_this);
2141     inst = PyInstance_NewRaw(data->newargs, dict);
2142     Py_DECREF(dict);
2143   }
2144   return inst;
2145 #else
2146 #if (PY_VERSION_HEX >= 0x02010000)
2147   PyObject *inst;
2148   PyObject *dict = PyDict_New();
2149   PyDict_SetItem(dict, SWIG_This(), swig_this);
2150   inst = PyInstance_NewRaw(data->newargs, dict);
2151   Py_DECREF(dict);
2152   return (PyObject *) inst;
2153 #else
2154   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2155   if (inst == NULL) {
2156     return NULL;
2157   }
2158   inst->in_class = (PyClassObject *)data->newargs;
2159   Py_INCREF(inst->in_class);
2160   inst->in_dict = PyDict_New();
2161   if (inst->in_dict == NULL) {
2162     Py_DECREF(inst);
2163     return NULL;
2164   }
2165 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2166   inst->in_weakreflist = NULL;
2167 #endif
2168 #ifdef Py_TPFLAGS_GC
2169   PyObject_GC_Init(inst);
2170 #endif
2171   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2172   return (PyObject *) inst;
2173 #endif
2174 #endif
2175 }
2176
2177 SWIGRUNTIME void
2178 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2179 {
2180  PyObject *dict;
2181 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2182  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2183  if (dictptr != NULL) {
2184    dict = *dictptr;
2185    if (dict == NULL) {
2186      dict = PyDict_New();
2187      *dictptr = dict;
2188    }
2189    PyDict_SetItem(dict, SWIG_This(), swig_this);
2190    return;
2191  }
2192 #endif
2193  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2194  PyDict_SetItem(dict, SWIG_This(), swig_this);
2195  Py_DECREF(dict);
2196
2197
2198
2199 SWIGINTERN PyObject *
2200 SWIG_Python_InitShadowInstance(PyObject *args) {
2201   PyObject *obj[2];
2202   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2203     return NULL;
2204   } else {
2205     PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2206     if (sthis) {
2207       PySwigObject_append((PyObject*) sthis, obj[1]);
2208     } else {
2209       SWIG_Python_SetSwigThis(obj[0], obj[1]);
2210     }
2211     return SWIG_Py_Void();
2212   }
2213 }
2214
2215 /* Create a new pointer object */
2216
2217 SWIGRUNTIME PyObject *
2218 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2219   if (!ptr) {
2220     return SWIG_Py_Void();
2221   } else {
2222     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2223     PyObject *robj = PySwigObject_New(ptr, type, own);
2224     PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2225     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2226       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2227       if (inst) {
2228         Py_DECREF(robj);
2229         robj = inst;
2230       }
2231     }
2232     return robj;
2233   }
2234 }
2235
2236 /* Create a new packed object */
2237
2238 SWIGRUNTIMEINLINE PyObject *
2239 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2240   return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2241 }
2242
2243 /* -----------------------------------------------------------------------------*
2244  *  Get type list 
2245  * -----------------------------------------------------------------------------*/
2246
2247 #ifdef SWIG_LINK_RUNTIME
2248 void *SWIG_ReturnGlobalTypeList(void *);
2249 #endif
2250
2251 SWIGRUNTIME swig_module_info *
2252 SWIG_Python_GetModule(void) {
2253   static void *type_pointer = (void *)0;
2254   /* first check if module already created */
2255   if (!type_pointer) {
2256 #ifdef SWIG_LINK_RUNTIME
2257     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2258 #else
2259     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2260                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2261     if (PyErr_Occurred()) {
2262       PyErr_Clear();
2263       type_pointer = (void *)0;
2264     }
2265 #endif
2266   }
2267   return (swig_module_info *) type_pointer;
2268 }
2269
2270 #if PY_MAJOR_VERSION < 2
2271 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
2272    is copied out of Python/modsupport.c in python version 2.3.4 */
2273 SWIGINTERN int
2274 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2275 {
2276   PyObject *dict;
2277   if (!PyModule_Check(m)) {
2278     PyErr_SetString(PyExc_TypeError,
2279                     "PyModule_AddObject() needs module as first arg");
2280     return SWIG_ERROR;
2281   }
2282   if (!o) {
2283     PyErr_SetString(PyExc_TypeError,
2284                     "PyModule_AddObject() needs non-NULL value");
2285     return SWIG_ERROR;
2286   }
2287   
2288   dict = PyModule_GetDict(m);
2289   if (dict == NULL) {
2290     /* Internal error -- modules must have a dict! */
2291     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2292                  PyModule_GetName(m));
2293     return SWIG_ERROR;
2294   }
2295   if (PyDict_SetItemString(dict, name, o))
2296     return SWIG_ERROR;
2297   Py_DECREF(o);
2298   return SWIG_OK;
2299 }
2300 #endif
2301
2302 SWIGRUNTIME void
2303 SWIG_Python_DestroyModule(void *vptr)
2304 {
2305   swig_module_info *swig_module = (swig_module_info *) vptr;
2306   swig_type_info **types = swig_module->types;
2307   size_t i;
2308   for (i =0; i < swig_module->size; ++i) {
2309     swig_type_info *ty = types[i];
2310     if (ty->owndata) {
2311       PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2312       if (data) PySwigClientData_Del(data);
2313     }
2314   }
2315   Py_DECREF(SWIG_This());
2316 }
2317
2318 SWIGRUNTIME void
2319 SWIG_Python_SetModule(swig_module_info *swig_module) {
2320   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2321
2322   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2323                                    swig_empty_runtime_method_table);
2324   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2325   if (pointer && module) {
2326     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2327   } else {
2328     Py_XDECREF(pointer);
2329   }
2330 }
2331
2332 /* The python cached type query */
2333 SWIGRUNTIME PyObject *
2334 SWIG_Python_TypeCache(void) {
2335   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2336   return cache;
2337 }
2338
2339 SWIGRUNTIME swig_type_info *
2340 SWIG_Python_TypeQuery(const char *type)
2341 {
2342   PyObject *cache = SWIG_Python_TypeCache();
2343   PyObject *key = PyString_FromString(type); 
2344   PyObject *obj = PyDict_GetItem(cache, key);
2345   swig_type_info *descriptor;
2346   if (obj) {
2347     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2348   } else {
2349     swig_module_info *swig_module = SWIG_Python_GetModule();
2350     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2351     if (descriptor) {
2352       obj = PyCObject_FromVoidPtr(descriptor, NULL);
2353       PyDict_SetItem(cache, key, obj);
2354       Py_DECREF(obj);
2355     }
2356   }
2357   Py_DECREF(key);
2358   return descriptor;
2359 }
2360
2361 /* 
2362    For backward compatibility only
2363 */
2364 #define SWIG_POINTER_EXCEPTION  0
2365 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2366 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2367
2368 SWIGRUNTIME int
2369 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2370 {
2371   if (PyErr_Occurred()) {
2372     PyObject *type = 0;
2373     PyObject *value = 0;
2374     PyObject *traceback = 0;
2375     PyErr_Fetch(&type, &value, &traceback);
2376     if (value) {
2377       PyObject *old_str = PyObject_Str(value);
2378       Py_XINCREF(type);
2379       PyErr_Clear();
2380       if (infront) {
2381         PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2382       } else {
2383         PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2384       }
2385       Py_DECREF(old_str);
2386     }
2387     return 1;
2388   } else {
2389     return 0;
2390   }
2391 }
2392   
2393 SWIGRUNTIME int
2394 SWIG_Python_ArgFail(int argnum)
2395 {
2396   if (PyErr_Occurred()) {
2397     /* add information about failing argument */
2398     char mesg[256];
2399     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2400     return SWIG_Python_AddErrMesg(mesg, 1);
2401   } else {
2402     return 0;
2403   }
2404 }
2405
2406 SWIGRUNTIMEINLINE const char *
2407 PySwigObject_GetDesc(PyObject *self)
2408 {
2409   PySwigObject *v = (PySwigObject *)self;
2410   swig_type_info *ty = v ? v->ty : 0;
2411   return ty ? ty->str : (char*)"";
2412 }
2413
2414 SWIGRUNTIME void
2415 SWIG_Python_TypeError(const char *type, PyObject *obj)
2416 {
2417   if (type) {
2418 #if defined(SWIG_COBJECT_TYPES)
2419     if (obj && PySwigObject_Check(obj)) {
2420       const char *otype = (const char *) PySwigObject_GetDesc(obj);
2421       if (otype) {
2422         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2423                      type, otype);
2424         return;
2425       }
2426     } else 
2427 #endif      
2428     {
2429       const char *otype = (obj ? obj->ob_type->tp_name : 0); 
2430       if (otype) {
2431         PyObject *str = PyObject_Str(obj);
2432         const char *cstr = str ? PyString_AsString(str) : 0;
2433         if (cstr) {
2434           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2435                        type, otype, cstr);
2436         } else {
2437           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2438                        type, otype);
2439         }
2440         Py_XDECREF(str);
2441         return;
2442       }
2443     }   
2444     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2445   } else {
2446     PyErr_Format(PyExc_TypeError, "unexpected type is received");
2447   }
2448 }
2449
2450
2451 /* Convert a pointer value, signal an exception on a type mismatch */
2452 SWIGRUNTIME void *
2453 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2454   void *result;
2455   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2456     PyErr_Clear();
2457     if (flags & SWIG_POINTER_EXCEPTION) {
2458       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2459       SWIG_Python_ArgFail(argnum);
2460     }
2461   }
2462   return result;
2463 }
2464
2465
2466 #ifdef __cplusplus
2467 #if 0
2468 { /* cc-mode */
2469 #endif
2470 }
2471 #endif
2472
2473
2474
2475 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
2476
2477 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
2478
2479
2480
2481 /* -------- TYPES TABLE (BEGIN) -------- */
2482
2483 #define SWIGTYPE_p_TDB_DATA swig_types[0]
2484 #define SWIGTYPE_p_char swig_types[1]
2485 #define SWIGTYPE_p_int swig_types[2]
2486 #define SWIGTYPE_p_long_long swig_types[3]
2487 #define SWIGTYPE_p_short swig_types[4]
2488 #define SWIGTYPE_p_signed_char swig_types[5]
2489 #define SWIGTYPE_p_tdb_context swig_types[6]
2490 #define SWIGTYPE_p_unsigned_char swig_types[7]
2491 #define SWIGTYPE_p_unsigned_int swig_types[8]
2492 #define SWIGTYPE_p_unsigned_long_long swig_types[9]
2493 #define SWIGTYPE_p_unsigned_short swig_types[10]
2494 static swig_type_info *swig_types[12];
2495 static swig_module_info swig_module = {swig_types, 11, 0, 0, 0, 0};
2496 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2497 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2498
2499 /* -------- TYPES TABLE (END) -------- */
2500
2501 #if (PY_VERSION_HEX <= 0x02000000)
2502 # if !defined(SWIG_PYTHON_CLASSIC)
2503 #  error "This python version requires swig to be run with the '-classic' option"
2504 # endif
2505 #endif
2506 #if (PY_VERSION_HEX <= 0x02020000)
2507 # error "This python version requires swig to be run with the '-nomodern' option"
2508 #endif
2509 #if (PY_VERSION_HEX <= 0x02020000)
2510 # error "This python version requires swig to be run with the '-nomodernargs' option"
2511 #endif
2512 #ifndef METH_O
2513 # error "This python version requires swig to be run with the '-nofastunpack' option"
2514 #endif
2515 #ifdef SWIG_TypeQuery
2516 # undef SWIG_TypeQuery
2517 #endif
2518 #define SWIG_TypeQuery SWIG_Python_TypeQuery
2519
2520 /*-----------------------------------------------
2521               @(target):= _tdb.so
2522   ------------------------------------------------*/
2523 #define SWIG_init    init_tdb
2524
2525 #define SWIG_name    "_tdb"
2526
2527 #define SWIGVERSION 0x010336 
2528 #define SWIG_VERSION SWIGVERSION
2529
2530
2531 #define SWIG_as_voidptr(a) (void *)((const void *)(a)) 
2532 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 
2533
2534
2535
2536 /* This symbol is used in both includes.h and Python.h which causes an
2537    annoying compiler warning. */
2538
2539 #ifdef HAVE_FSTAT
2540 #undef HAVE_FSTAT
2541 #endif
2542
2543 /* Include tdb headers */
2544 #include <stdint.h>
2545 #include <signal.h>
2546 #include <tdb.h>
2547 #include <fcntl.h>
2548
2549 typedef TDB_CONTEXT tdb;
2550
2551
2552   #define SWIG_From_long   PyInt_FromLong 
2553
2554
2555 SWIGINTERNINLINE PyObject *
2556 SWIG_From_int  (int value)
2557 {    
2558   return SWIG_From_long  (value);
2559 }
2560
2561
2562 SWIGINTERN swig_type_info*
2563 SWIG_pchar_descriptor(void)
2564 {
2565   static int init = 0;
2566   static swig_type_info* info = 0;
2567   if (!init) {
2568     info = SWIG_TypeQuery("_p_char");
2569     init = 1;
2570   }
2571   return info;
2572 }
2573
2574
2575 SWIGINTERN int
2576 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2577 {
2578   if (PyString_Check(obj)) {
2579     char *cstr; Py_ssize_t len;
2580     PyString_AsStringAndSize(obj, &cstr, &len);
2581     if (cptr)  {
2582       if (alloc) {
2583         /* 
2584            In python the user should not be able to modify the inner
2585            string representation. To warranty that, if you define
2586            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
2587            buffer is always returned.
2588
2589            The default behavior is just to return the pointer value,
2590            so, be careful.
2591         */ 
2592 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
2593         if (*alloc != SWIG_OLDOBJ) 
2594 #else
2595         if (*alloc == SWIG_NEWOBJ) 
2596 #endif
2597           {
2598             *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
2599             *alloc = SWIG_NEWOBJ;
2600           }
2601         else {
2602           *cptr = cstr;
2603           *alloc = SWIG_OLDOBJ;
2604         }
2605       } else {
2606         *cptr = PyString_AsString(obj);
2607       }
2608     }
2609     if (psize) *psize = len + 1;
2610     return SWIG_OK;
2611   } else {
2612     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2613     if (pchar_descriptor) {
2614       void* vptr = 0;
2615       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
2616         if (cptr) *cptr = (char *) vptr;
2617         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
2618         if (alloc) *alloc = SWIG_OLDOBJ;
2619         return SWIG_OK;
2620       }
2621     }
2622   }
2623   return SWIG_TypeError;
2624 }
2625
2626
2627
2628
2629
2630 #include <limits.h>
2631 #if !defined(SWIG_NO_LLONG_MAX)
2632 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2633 #   define LLONG_MAX __LONG_LONG_MAX__
2634 #   define LLONG_MIN (-LLONG_MAX - 1LL)
2635 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2636 # endif
2637 #endif
2638
2639
2640 SWIGINTERN int
2641 SWIG_AsVal_double (PyObject *obj, double *val)
2642 {
2643   int res = SWIG_TypeError;
2644   if (PyFloat_Check(obj)) {
2645     if (val) *val = PyFloat_AsDouble(obj);
2646     return SWIG_OK;
2647   } else if (PyInt_Check(obj)) {
2648     if (val) *val = PyInt_AsLong(obj);
2649     return SWIG_OK;
2650   } else if (PyLong_Check(obj)) {
2651     double v = PyLong_AsDouble(obj);
2652     if (!PyErr_Occurred()) {
2653       if (val) *val = v;
2654       return SWIG_OK;
2655     } else {
2656       PyErr_Clear();
2657     }
2658   }
2659 #ifdef SWIG_PYTHON_CAST_MODE
2660   {
2661     int dispatch = 0;
2662     double d = PyFloat_AsDouble(obj);
2663     if (!PyErr_Occurred()) {
2664       if (val) *val = d;
2665       return SWIG_AddCast(SWIG_OK);
2666     } else {
2667       PyErr_Clear();
2668     }
2669     if (!dispatch) {
2670       long v = PyLong_AsLong(obj);
2671       if (!PyErr_Occurred()) {
2672         if (val) *val = v;
2673         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2674       } else {
2675         PyErr_Clear();
2676       }
2677     }
2678   }
2679 #endif
2680   return res;
2681 }
2682
2683
2684 #include <float.h>
2685
2686
2687 #include <math.h>
2688
2689
2690 SWIGINTERNINLINE int
2691 SWIG_CanCastAsInteger(double *d, double min, double max) {
2692   double x = *d;
2693   if ((min <= x && x <= max)) {
2694    double fx = floor(x);
2695    double cx = ceil(x);
2696    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2697    if ((errno == EDOM) || (errno == ERANGE)) {
2698      errno = 0;
2699    } else {
2700      double summ, reps, diff;
2701      if (rd < x) {
2702        diff = x - rd;
2703      } else if (rd > x) {
2704        diff = rd - x;
2705      } else {
2706        return 1;
2707      }
2708      summ = rd + x;
2709      reps = diff/summ;
2710      if (reps < 8*DBL_EPSILON) {
2711        *d = rd;
2712        return 1;
2713      }
2714    }
2715   }
2716   return 0;
2717 }
2718
2719
2720 SWIGINTERN int
2721 SWIG_AsVal_long (PyObject *obj, long* val)
2722 {
2723   if (PyInt_Check(obj)) {
2724     if (val) *val = PyInt_AsLong(obj);
2725     return SWIG_OK;
2726   } else if (PyLong_Check(obj)) {
2727     long v = PyLong_AsLong(obj);
2728     if (!PyErr_Occurred()) {
2729       if (val) *val = v;
2730       return SWIG_OK;
2731     } else {
2732       PyErr_Clear();
2733     }
2734   }
2735 #ifdef SWIG_PYTHON_CAST_MODE
2736   {
2737     int dispatch = 0;
2738     long v = PyInt_AsLong(obj);
2739     if (!PyErr_Occurred()) {
2740       if (val) *val = v;
2741       return SWIG_AddCast(SWIG_OK);
2742     } else {
2743       PyErr_Clear();
2744     }
2745     if (!dispatch) {
2746       double d;
2747       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2748       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2749         if (val) *val = (long)(d);
2750         return res;
2751       }
2752     }
2753   }
2754 #endif
2755   return SWIG_TypeError;
2756 }
2757
2758
2759 SWIGINTERN int
2760 SWIG_AsVal_int (PyObject * obj, int *val)
2761 {
2762   long v;
2763   int res = SWIG_AsVal_long (obj, &v);
2764   if (SWIG_IsOK(res)) {
2765     if ((v < INT_MIN || v > INT_MAX)) {
2766       return SWIG_OverflowError;
2767     } else {
2768       if (val) *val = (int)(v);
2769     }
2770   }  
2771   return res;
2772 }
2773
2774 SWIGINTERN tdb *new_tdb(char const *name,int hash_size,int tdb_flags,int flags,mode_t mode){
2775             return tdb_open(name, hash_size, tdb_flags, flags, mode);
2776         }
2777 SWIGINTERN void delete_tdb(tdb *self){ tdb_close(self); }
2778
2779 SWIGINTERNINLINE PyObject *
2780 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2781 {
2782   if (carray) {
2783     if (size > INT_MAX) {
2784       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2785       return pchar_descriptor ? 
2786         SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2787     } else {
2788       return PyString_FromStringAndSize(carray, (int)(size));
2789     }
2790   } else {
2791     return SWIG_Py_Void();
2792   }
2793 }
2794
2795
2796 SWIGINTERNINLINE PyObject * 
2797 SWIG_FromCharPtr(const char *cptr)
2798
2799   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2800 }
2801
2802
2803 SWIGINTERNINLINE PyObject* 
2804 SWIG_From_unsigned_SS_long  (unsigned long value)
2805 {
2806   return (value > LONG_MAX) ?
2807     PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value)); 
2808 }
2809
2810
2811 SWIGINTERNINLINE PyObject *
2812 SWIG_From_size_t  (size_t value)
2813 {    
2814   return SWIG_From_unsigned_SS_long  ((unsigned long)(value));
2815 }
2816
2817 #ifdef __cplusplus
2818 extern "C" {
2819 #endif
2820 SWIGINTERN PyObject *_wrap_new_Tdb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
2821   PyObject *resultobj = 0;
2822   char *arg1 = (char *) 0 ;
2823   int arg2 ;
2824   int arg3 ;
2825   int arg4 ;
2826   mode_t arg5 ;
2827   int res1 ;
2828   char *buf1 = 0 ;
2829   int alloc1 = 0 ;
2830   int val2 ;
2831   int ecode2 = 0 ;
2832   int val3 ;
2833   int ecode3 = 0 ;
2834   int val4 ;
2835   int ecode4 = 0 ;
2836   int val5 ;
2837   int ecode5 = 0 ;
2838   PyObject * obj0 = 0 ;
2839   PyObject * obj1 = 0 ;
2840   PyObject * obj2 = 0 ;
2841   PyObject * obj3 = 0 ;
2842   PyObject * obj4 = 0 ;
2843   char *  kwnames[] = {
2844     (char *) "name",(char *) "hash_size",(char *) "tdb_flags",(char *) "flags",(char *) "mode", NULL 
2845   };
2846   tdb *result = 0 ;
2847   
2848   arg2 = 0;
2849   arg3 = TDB_DEFAULT;
2850   arg4 = O_RDWR;
2851   arg5 = 0600;
2852   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:new_Tdb",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
2853   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
2854   if (!SWIG_IsOK(res1)) {
2855     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Tdb" "', argument " "1"" of type '" "char const *""'");
2856   }
2857   arg1 = (char *)(buf1);
2858   if (obj1) {
2859     ecode2 = SWIG_AsVal_int(obj1, &val2);
2860     if (!SWIG_IsOK(ecode2)) {
2861       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Tdb" "', argument " "2"" of type '" "int""'");
2862     } 
2863     arg2 = (int)(val2);
2864   }
2865   if (obj2) {
2866     ecode3 = SWIG_AsVal_int(obj2, &val3);
2867     if (!SWIG_IsOK(ecode3)) {
2868       SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Tdb" "', argument " "3"" of type '" "int""'");
2869     } 
2870     arg3 = (int)(val3);
2871   }
2872   if (obj3) {
2873     ecode4 = SWIG_AsVal_int(obj3, &val4);
2874     if (!SWIG_IsOK(ecode4)) {
2875       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Tdb" "', argument " "4"" of type '" "int""'");
2876     } 
2877     arg4 = (int)(val4);
2878   }
2879   if (obj4) {
2880     ecode5 = SWIG_AsVal_int(obj4, &val5);
2881     if (!SWIG_IsOK(ecode5)) {
2882       SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Tdb" "', argument " "5"" of type '" "mode_t""'");
2883     } 
2884     arg5 = (mode_t)(val5);
2885   }
2886   result = (tdb *)new_tdb((char const *)arg1,arg2,arg3,arg4,arg5);
2887   /* Throw an IOError exception from errno if tdb_open() returns NULL */
2888   if (result == NULL) {
2889     PyErr_SetFromErrno(PyExc_IOError);
2890     SWIG_fail;
2891   }
2892   resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_tdb_context, 0);
2893   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2894   return resultobj;
2895 fail:
2896   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2897   return NULL;
2898 }
2899
2900
2901 SWIGINTERN PyObject *_wrap_Tdb_error(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2902   PyObject *resultobj = 0;
2903   tdb *arg1 = (tdb *) 0 ;
2904   void *argp1 = 0 ;
2905   int res1 = 0 ;
2906   PyObject *swig_obj[1] ;
2907   enum TDB_ERROR result;
2908   
2909   if (!args) SWIG_fail;
2910   swig_obj[0] = args;
2911   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
2912   if (!SWIG_IsOK(res1)) {
2913     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_error" "', argument " "1"" of type '" "tdb *""'"); 
2914   }
2915   arg1 = (tdb *)(argp1);
2916   result = (enum TDB_ERROR)tdb_error(arg1);
2917   resultobj = SWIG_From_int((int)(result));
2918   return resultobj;
2919 fail:
2920   return NULL;
2921 }
2922
2923
2924 SWIGINTERN PyObject *_wrap_delete_Tdb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2925   PyObject *resultobj = 0;
2926   tdb *arg1 = (tdb *) 0 ;
2927   void *argp1 = 0 ;
2928   int res1 = 0 ;
2929   PyObject *swig_obj[1] ;
2930   
2931   if (!args) SWIG_fail;
2932   swig_obj[0] = args;
2933   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, SWIG_POINTER_DISOWN |  0 );
2934   if (!SWIG_IsOK(res1)) {
2935     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Tdb" "', argument " "1"" of type '" "tdb *""'"); 
2936   }
2937   arg1 = (tdb *)(argp1);
2938   delete_tdb(arg1);
2939   resultobj = SWIG_Py_Void();
2940   return resultobj;
2941 fail:
2942   return NULL;
2943 }
2944
2945
2946 SWIGINTERN PyObject *_wrap_Tdb_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2947   PyObject *resultobj = 0;
2948   tdb *arg1 = (tdb *) 0 ;
2949   void *argp1 = 0 ;
2950   int res1 = 0 ;
2951   PyObject *swig_obj[1] ;
2952   int result;
2953   
2954   if (!args) SWIG_fail;
2955   swig_obj[0] = args;
2956   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
2957   if (!SWIG_IsOK(res1)) {
2958     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_close" "', argument " "1"" of type '" "tdb *""'"); 
2959   }
2960   arg1 = (tdb *)(argp1);
2961   result = (int)tdb_close(arg1);
2962   resultobj = SWIG_From_int((int)(result));
2963   return resultobj;
2964 fail:
2965   return NULL;
2966 }
2967
2968
2969 SWIGINTERN PyObject *_wrap_Tdb_append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
2970   PyObject *resultobj = 0;
2971   tdb *arg1 = (tdb *) 0 ;
2972   TDB_DATA arg2 ;
2973   TDB_DATA arg3 ;
2974   void *argp1 = 0 ;
2975   int res1 = 0 ;
2976   PyObject * obj0 = 0 ;
2977   PyObject * obj1 = 0 ;
2978   PyObject * obj2 = 0 ;
2979   char *  kwnames[] = {
2980     (char *) "self",(char *) "key",(char *) "new_dbuf", NULL 
2981   };
2982   int result;
2983   
2984   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Tdb_append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
2985   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
2986   if (!SWIG_IsOK(res1)) {
2987     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_append" "', argument " "1"" of type '" "tdb *""'"); 
2988   }
2989   arg1 = (tdb *)(argp1);
2990   if (obj1 == Py_None) {
2991     (&arg2)->dsize = 0;
2992     (&arg2)->dptr = NULL;
2993   } else if (!PyString_Check(obj1)) {
2994     PyErr_SetString(PyExc_TypeError, "string arg expected");
2995     return NULL;
2996   } else {
2997     (&arg2)->dsize = PyString_Size(obj1);
2998     (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
2999   }
3000   if (obj2 == Py_None) {
3001     (&arg3)->dsize = 0;
3002     (&arg3)->dptr = NULL;
3003   } else if (!PyString_Check(obj2)) {
3004     PyErr_SetString(PyExc_TypeError, "string arg expected");
3005     return NULL;
3006   } else {
3007     (&arg3)->dsize = PyString_Size(obj2);
3008     (&arg3)->dptr = (uint8_t *)PyString_AsString(obj2);
3009   }
3010   result = (int)tdb_append(arg1,arg2,arg3);
3011   resultobj = SWIG_From_int((int)(result));
3012   return resultobj;
3013 fail:
3014   return NULL;
3015 }
3016
3017
3018 SWIGINTERN PyObject *_wrap_Tdb_errorstr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3019   PyObject *resultobj = 0;
3020   tdb *arg1 = (tdb *) 0 ;
3021   void *argp1 = 0 ;
3022   int res1 = 0 ;
3023   PyObject *swig_obj[1] ;
3024   char *result = 0 ;
3025   
3026   if (!args) SWIG_fail;
3027   swig_obj[0] = args;
3028   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3029   if (!SWIG_IsOK(res1)) {
3030     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_errorstr" "', argument " "1"" of type '" "tdb *""'"); 
3031   }
3032   arg1 = (tdb *)(argp1);
3033   result = (char *)tdb_errorstr(arg1);
3034   resultobj = SWIG_FromCharPtr((const char *)result);
3035   return resultobj;
3036 fail:
3037   return NULL;
3038 }
3039
3040
3041 SWIGINTERN PyObject *_wrap_Tdb_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3042   PyObject *resultobj = 0;
3043   tdb *arg1 = (tdb *) 0 ;
3044   TDB_DATA arg2 ;
3045   void *argp1 = 0 ;
3046   int res1 = 0 ;
3047   PyObject * obj0 = 0 ;
3048   PyObject * obj1 = 0 ;
3049   char *  kwnames[] = {
3050     (char *) "self",(char *) "key", NULL 
3051   };
3052   TDB_DATA result;
3053   
3054   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_get",kwnames,&obj0,&obj1)) SWIG_fail;
3055   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3056   if (!SWIG_IsOK(res1)) {
3057     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_get" "', argument " "1"" of type '" "tdb *""'"); 
3058   }
3059   arg1 = (tdb *)(argp1);
3060   if (obj1 == Py_None) {
3061     (&arg2)->dsize = 0;
3062     (&arg2)->dptr = NULL;
3063   } else if (!PyString_Check(obj1)) {
3064     PyErr_SetString(PyExc_TypeError, "string arg expected");
3065     return NULL;
3066   } else {
3067     (&arg2)->dsize = PyString_Size(obj1);
3068     (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
3069   }
3070   result = tdb_fetch(arg1,arg2);
3071   if ((&result)->dptr == NULL && (&result)->dsize == 0) {
3072     resultobj = Py_None;
3073   } else {
3074     resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
3075     free((&result)->dptr);
3076   }
3077   return resultobj;
3078 fail:
3079   return NULL;
3080 }
3081
3082
3083 SWIGINTERN PyObject *_wrap_Tdb_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3084   PyObject *resultobj = 0;
3085   tdb *arg1 = (tdb *) 0 ;
3086   TDB_DATA arg2 ;
3087   void *argp1 = 0 ;
3088   int res1 = 0 ;
3089   PyObject * obj0 = 0 ;
3090   PyObject * obj1 = 0 ;
3091   char *  kwnames[] = {
3092     (char *) "self",(char *) "key", NULL 
3093   };
3094   int result;
3095   
3096   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_delete",kwnames,&obj0,&obj1)) SWIG_fail;
3097   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3098   if (!SWIG_IsOK(res1)) {
3099     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_delete" "', argument " "1"" of type '" "tdb *""'"); 
3100   }
3101   arg1 = (tdb *)(argp1);
3102   if (obj1 == Py_None) {
3103     (&arg2)->dsize = 0;
3104     (&arg2)->dptr = NULL;
3105   } else if (!PyString_Check(obj1)) {
3106     PyErr_SetString(PyExc_TypeError, "string arg expected");
3107     return NULL;
3108   } else {
3109     (&arg2)->dsize = PyString_Size(obj1);
3110     (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
3111   }
3112   result = (int)tdb_delete(arg1,arg2);
3113   resultobj = SWIG_From_int((int)(result));
3114   return resultobj;
3115 fail:
3116   return NULL;
3117 }
3118
3119
3120 SWIGINTERN PyObject *_wrap_Tdb_store(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3121   PyObject *resultobj = 0;
3122   tdb *arg1 = (tdb *) 0 ;
3123   TDB_DATA arg2 ;
3124   TDB_DATA arg3 ;
3125   int arg4 ;
3126   void *argp1 = 0 ;
3127   int res1 = 0 ;
3128   int val4 ;
3129   int ecode4 = 0 ;
3130   PyObject * obj0 = 0 ;
3131   PyObject * obj1 = 0 ;
3132   PyObject * obj2 = 0 ;
3133   PyObject * obj3 = 0 ;
3134   char *  kwnames[] = {
3135     (char *) "self",(char *) "key",(char *) "dbuf",(char *) "flag", NULL 
3136   };
3137   int result;
3138   
3139   arg4 = TDB_REPLACE;
3140   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Tdb_store",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3141   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3142   if (!SWIG_IsOK(res1)) {
3143     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_store" "', argument " "1"" of type '" "tdb *""'"); 
3144   }
3145   arg1 = (tdb *)(argp1);
3146   if (obj1 == Py_None) {
3147     (&arg2)->dsize = 0;
3148     (&arg2)->dptr = NULL;
3149   } else if (!PyString_Check(obj1)) {
3150     PyErr_SetString(PyExc_TypeError, "string arg expected");
3151     return NULL;
3152   } else {
3153     (&arg2)->dsize = PyString_Size(obj1);
3154     (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
3155   }
3156   if (obj2 == Py_None) {
3157     (&arg3)->dsize = 0;
3158     (&arg3)->dptr = NULL;
3159   } else if (!PyString_Check(obj2)) {
3160     PyErr_SetString(PyExc_TypeError, "string arg expected");
3161     return NULL;
3162   } else {
3163     (&arg3)->dsize = PyString_Size(obj2);
3164     (&arg3)->dptr = (uint8_t *)PyString_AsString(obj2);
3165   }
3166   if (obj3) {
3167     ecode4 = SWIG_AsVal_int(obj3, &val4);
3168     if (!SWIG_IsOK(ecode4)) {
3169       SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Tdb_store" "', argument " "4"" of type '" "int""'");
3170     } 
3171     arg4 = (int)(val4);
3172   }
3173   result = (int)tdb_store(arg1,arg2,arg3,arg4);
3174   resultobj = SWIG_From_int((int)(result));
3175   return resultobj;
3176 fail:
3177   return NULL;
3178 }
3179
3180
3181 SWIGINTERN PyObject *_wrap_Tdb_exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3182   PyObject *resultobj = 0;
3183   tdb *arg1 = (tdb *) 0 ;
3184   TDB_DATA arg2 ;
3185   void *argp1 = 0 ;
3186   int res1 = 0 ;
3187   PyObject * obj0 = 0 ;
3188   PyObject * obj1 = 0 ;
3189   char *  kwnames[] = {
3190     (char *) "self",(char *) "key", NULL 
3191   };
3192   int result;
3193   
3194   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_exists",kwnames,&obj0,&obj1)) SWIG_fail;
3195   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3196   if (!SWIG_IsOK(res1)) {
3197     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_exists" "', argument " "1"" of type '" "tdb *""'"); 
3198   }
3199   arg1 = (tdb *)(argp1);
3200   if (obj1 == Py_None) {
3201     (&arg2)->dsize = 0;
3202     (&arg2)->dptr = NULL;
3203   } else if (!PyString_Check(obj1)) {
3204     PyErr_SetString(PyExc_TypeError, "string arg expected");
3205     return NULL;
3206   } else {
3207     (&arg2)->dsize = PyString_Size(obj1);
3208     (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
3209   }
3210   result = (int)tdb_exists(arg1,arg2);
3211   resultobj = SWIG_From_int((int)(result));
3212   return resultobj;
3213 fail:
3214   return NULL;
3215 }
3216
3217
3218 SWIGINTERN PyObject *_wrap_Tdb_firstkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3219   PyObject *resultobj = 0;
3220   tdb *arg1 = (tdb *) 0 ;
3221   void *argp1 = 0 ;
3222   int res1 = 0 ;
3223   PyObject *swig_obj[1] ;
3224   TDB_DATA result;
3225   
3226   if (!args) SWIG_fail;
3227   swig_obj[0] = args;
3228   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3229   if (!SWIG_IsOK(res1)) {
3230     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_firstkey" "', argument " "1"" of type '" "tdb *""'"); 
3231   }
3232   arg1 = (tdb *)(argp1);
3233   result = tdb_firstkey(arg1);
3234   if ((&result)->dptr == NULL && (&result)->dsize == 0) {
3235     resultobj = Py_None;
3236   } else {
3237     resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
3238     free((&result)->dptr);
3239   }
3240   return resultobj;
3241 fail:
3242   return NULL;
3243 }
3244
3245
3246 SWIGINTERN PyObject *_wrap_Tdb_nextkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3247   PyObject *resultobj = 0;
3248   tdb *arg1 = (tdb *) 0 ;
3249   TDB_DATA arg2 ;
3250   void *argp1 = 0 ;
3251   int res1 = 0 ;
3252   PyObject * obj0 = 0 ;
3253   PyObject * obj1 = 0 ;
3254   char *  kwnames[] = {
3255     (char *) "self",(char *) "key", NULL 
3256   };
3257   TDB_DATA result;
3258   
3259   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_nextkey",kwnames,&obj0,&obj1)) SWIG_fail;
3260   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3261   if (!SWIG_IsOK(res1)) {
3262     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_nextkey" "', argument " "1"" of type '" "tdb *""'"); 
3263   }
3264   arg1 = (tdb *)(argp1);
3265   if (obj1 == Py_None) {
3266     (&arg2)->dsize = 0;
3267     (&arg2)->dptr = NULL;
3268   } else if (!PyString_Check(obj1)) {
3269     PyErr_SetString(PyExc_TypeError, "string arg expected");
3270     return NULL;
3271   } else {
3272     (&arg2)->dsize = PyString_Size(obj1);
3273     (&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
3274   }
3275   result = tdb_nextkey(arg1,arg2);
3276   if ((&result)->dptr == NULL && (&result)->dsize == 0) {
3277     resultobj = Py_None;
3278   } else {
3279     resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
3280     free((&result)->dptr);
3281   }
3282   return resultobj;
3283 fail:
3284   return NULL;
3285 }
3286
3287
3288 SWIGINTERN PyObject *_wrap_Tdb_lock_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3289   PyObject *resultobj = 0;
3290   tdb *arg1 = (tdb *) 0 ;
3291   void *argp1 = 0 ;
3292   int res1 = 0 ;
3293   PyObject *swig_obj[1] ;
3294   int result;
3295   
3296   if (!args) SWIG_fail;
3297   swig_obj[0] = args;
3298   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3299   if (!SWIG_IsOK(res1)) {
3300     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_lock_all" "', argument " "1"" of type '" "tdb *""'"); 
3301   }
3302   arg1 = (tdb *)(argp1);
3303   result = (int)tdb_lockall(arg1);
3304   resultobj = SWIG_From_int((int)(result));
3305   return resultobj;
3306 fail:
3307   return NULL;
3308 }
3309
3310
3311 SWIGINTERN PyObject *_wrap_Tdb_unlock_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3312   PyObject *resultobj = 0;
3313   tdb *arg1 = (tdb *) 0 ;
3314   void *argp1 = 0 ;
3315   int res1 = 0 ;
3316   PyObject *swig_obj[1] ;
3317   int result;
3318   
3319   if (!args) SWIG_fail;
3320   swig_obj[0] = args;
3321   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3322   if (!SWIG_IsOK(res1)) {
3323     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_unlock_all" "', argument " "1"" of type '" "tdb *""'"); 
3324   }
3325   arg1 = (tdb *)(argp1);
3326   result = (int)tdb_unlockall(arg1);
3327   resultobj = SWIG_From_int((int)(result));
3328   return resultobj;
3329 fail:
3330   return NULL;
3331 }
3332
3333
3334 SWIGINTERN PyObject *_wrap_Tdb_read_lock_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3335   PyObject *resultobj = 0;
3336   tdb *arg1 = (tdb *) 0 ;
3337   void *argp1 = 0 ;
3338   int res1 = 0 ;
3339   PyObject *swig_obj[1] ;
3340   int result;
3341   
3342   if (!args) SWIG_fail;
3343   swig_obj[0] = args;
3344   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3345   if (!SWIG_IsOK(res1)) {
3346     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_read_lock_all" "', argument " "1"" of type '" "tdb *""'"); 
3347   }
3348   arg1 = (tdb *)(argp1);
3349   result = (int)tdb_lockall_read(arg1);
3350   resultobj = SWIG_From_int((int)(result));
3351   return resultobj;
3352 fail:
3353   return NULL;
3354 }
3355
3356
3357 SWIGINTERN PyObject *_wrap_Tdb_read_unlock_all(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3358   PyObject *resultobj = 0;
3359   tdb *arg1 = (tdb *) 0 ;
3360   void *argp1 = 0 ;
3361   int res1 = 0 ;
3362   PyObject *swig_obj[1] ;
3363   int result;
3364   
3365   if (!args) SWIG_fail;
3366   swig_obj[0] = args;
3367   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3368   if (!SWIG_IsOK(res1)) {
3369     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_read_unlock_all" "', argument " "1"" of type '" "tdb *""'"); 
3370   }
3371   arg1 = (tdb *)(argp1);
3372   result = (int)tdb_unlockall_read(arg1);
3373   resultobj = SWIG_From_int((int)(result));
3374   return resultobj;
3375 fail:
3376   return NULL;
3377 }
3378
3379
3380 SWIGINTERN PyObject *_wrap_Tdb_reopen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3381   PyObject *resultobj = 0;
3382   tdb *arg1 = (tdb *) 0 ;
3383   void *argp1 = 0 ;
3384   int res1 = 0 ;
3385   PyObject *swig_obj[1] ;
3386   int result;
3387   
3388   if (!args) SWIG_fail;
3389   swig_obj[0] = args;
3390   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3391   if (!SWIG_IsOK(res1)) {
3392     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_reopen" "', argument " "1"" of type '" "tdb *""'"); 
3393   }
3394   arg1 = (tdb *)(argp1);
3395   result = (int)tdb_reopen(arg1);
3396   resultobj = SWIG_From_int((int)(result));
3397   return resultobj;
3398 fail:
3399   return NULL;
3400 }
3401
3402
3403 SWIGINTERN PyObject *_wrap_Tdb_transaction_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3404   PyObject *resultobj = 0;
3405   tdb *arg1 = (tdb *) 0 ;
3406   void *argp1 = 0 ;
3407   int res1 = 0 ;
3408   PyObject *swig_obj[1] ;
3409   int result;
3410   
3411   if (!args) SWIG_fail;
3412   swig_obj[0] = args;
3413   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3414   if (!SWIG_IsOK(res1)) {
3415     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_transaction_start" "', argument " "1"" of type '" "tdb *""'"); 
3416   }
3417   arg1 = (tdb *)(argp1);
3418   result = (int)tdb_transaction_start(arg1);
3419   resultobj = SWIG_From_int((int)(result));
3420   return resultobj;
3421 fail:
3422   return NULL;
3423 }
3424
3425
3426 SWIGINTERN PyObject *_wrap_Tdb_transaction_commit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3427   PyObject *resultobj = 0;
3428   tdb *arg1 = (tdb *) 0 ;
3429   void *argp1 = 0 ;
3430   int res1 = 0 ;
3431   PyObject *swig_obj[1] ;
3432   int result;
3433   
3434   if (!args) SWIG_fail;
3435   swig_obj[0] = args;
3436   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3437   if (!SWIG_IsOK(res1)) {
3438     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_transaction_commit" "', argument " "1"" of type '" "tdb *""'"); 
3439   }
3440   arg1 = (tdb *)(argp1);
3441   result = (int)tdb_transaction_commit(arg1);
3442   resultobj = SWIG_From_int((int)(result));
3443   return resultobj;
3444 fail:
3445   return NULL;
3446 }
3447
3448
3449 SWIGINTERN PyObject *_wrap_Tdb_transaction_cancel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3450   PyObject *resultobj = 0;
3451   tdb *arg1 = (tdb *) 0 ;
3452   void *argp1 = 0 ;
3453   int res1 = 0 ;
3454   PyObject *swig_obj[1] ;
3455   int result;
3456   
3457   if (!args) SWIG_fail;
3458   swig_obj[0] = args;
3459   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3460   if (!SWIG_IsOK(res1)) {
3461     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_transaction_cancel" "', argument " "1"" of type '" "tdb *""'"); 
3462   }
3463   arg1 = (tdb *)(argp1);
3464   result = (int)tdb_transaction_cancel(arg1);
3465   resultobj = SWIG_From_int((int)(result));
3466   return resultobj;
3467 fail:
3468   return NULL;
3469 }
3470
3471
3472 SWIGINTERN PyObject *_wrap_Tdb_transaction_recover(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3473   PyObject *resultobj = 0;
3474   tdb *arg1 = (tdb *) 0 ;
3475   void *argp1 = 0 ;
3476   int res1 = 0 ;
3477   PyObject *swig_obj[1] ;
3478   int result;
3479   
3480   if (!args) SWIG_fail;
3481   swig_obj[0] = args;
3482   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3483   if (!SWIG_IsOK(res1)) {
3484     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_transaction_recover" "', argument " "1"" of type '" "tdb *""'"); 
3485   }
3486   arg1 = (tdb *)(argp1);
3487   result = (int)tdb_transaction_recover(arg1);
3488   resultobj = SWIG_From_int((int)(result));
3489   return resultobj;
3490 fail:
3491   return NULL;
3492 }
3493
3494
3495 SWIGINTERN PyObject *_wrap_Tdb_hash_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3496   PyObject *resultobj = 0;
3497   tdb *arg1 = (tdb *) 0 ;
3498   void *argp1 = 0 ;
3499   int res1 = 0 ;
3500   PyObject *swig_obj[1] ;
3501   int result;
3502   
3503   if (!args) SWIG_fail;
3504   swig_obj[0] = args;
3505   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3506   if (!SWIG_IsOK(res1)) {
3507     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_hash_size" "', argument " "1"" of type '" "tdb *""'"); 
3508   }
3509   arg1 = (tdb *)(argp1);
3510   result = (int)tdb_hash_size(arg1);
3511   resultobj = SWIG_From_int((int)(result));
3512   return resultobj;
3513 fail:
3514   return NULL;
3515 }
3516
3517
3518 SWIGINTERN PyObject *_wrap_Tdb_map_size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3519   PyObject *resultobj = 0;
3520   tdb *arg1 = (tdb *) 0 ;
3521   void *argp1 = 0 ;
3522   int res1 = 0 ;
3523   PyObject *swig_obj[1] ;
3524   size_t result;
3525   
3526   if (!args) SWIG_fail;
3527   swig_obj[0] = args;
3528   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3529   if (!SWIG_IsOK(res1)) {
3530     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_map_size" "', argument " "1"" of type '" "tdb *""'"); 
3531   }
3532   arg1 = (tdb *)(argp1);
3533   result = tdb_map_size(arg1);
3534   resultobj = SWIG_From_size_t((size_t)(result));
3535   return resultobj;
3536 fail:
3537   return NULL;
3538 }
3539
3540
3541 SWIGINTERN PyObject *_wrap_Tdb_get_flags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3542   PyObject *resultobj = 0;
3543   tdb *arg1 = (tdb *) 0 ;
3544   void *argp1 = 0 ;
3545   int res1 = 0 ;
3546   PyObject *swig_obj[1] ;
3547   int result;
3548   
3549   if (!args) SWIG_fail;
3550   swig_obj[0] = args;
3551   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3552   if (!SWIG_IsOK(res1)) {
3553     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_get_flags" "', argument " "1"" of type '" "tdb *""'"); 
3554   }
3555   arg1 = (tdb *)(argp1);
3556   result = (int)tdb_get_flags(arg1);
3557   resultobj = SWIG_From_int((int)(result));
3558   return resultobj;
3559 fail:
3560   return NULL;
3561 }
3562
3563
3564 SWIGINTERN PyObject *_wrap_Tdb_set_max_dead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
3565   PyObject *resultobj = 0;
3566   tdb *arg1 = (tdb *) 0 ;
3567   int arg2 ;
3568   void *argp1 = 0 ;
3569   int res1 = 0 ;
3570   int val2 ;
3571   int ecode2 = 0 ;
3572   PyObject * obj0 = 0 ;
3573   PyObject * obj1 = 0 ;
3574   char *  kwnames[] = {
3575     (char *) "self",(char *) "max_dead", NULL 
3576   };
3577   
3578   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_set_max_dead",kwnames,&obj0,&obj1)) SWIG_fail;
3579   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3580   if (!SWIG_IsOK(res1)) {
3581     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_set_max_dead" "', argument " "1"" of type '" "tdb *""'"); 
3582   }
3583   arg1 = (tdb *)(argp1);
3584   ecode2 = SWIG_AsVal_int(obj1, &val2);
3585   if (!SWIG_IsOK(ecode2)) {
3586     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tdb_set_max_dead" "', argument " "2"" of type '" "int""'");
3587   } 
3588   arg2 = (int)(val2);
3589   tdb_set_max_dead(arg1,arg2);
3590   resultobj = SWIG_Py_Void();
3591   return resultobj;
3592 fail:
3593   return NULL;
3594 }
3595
3596
3597 SWIGINTERN PyObject *_wrap_Tdb_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3598   PyObject *resultobj = 0;
3599   tdb *arg1 = (tdb *) 0 ;
3600   void *argp1 = 0 ;
3601   int res1 = 0 ;
3602   PyObject *swig_obj[1] ;
3603   char *result = 0 ;
3604   
3605   if (!args) SWIG_fail;
3606   swig_obj[0] = args;
3607   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 |  0 );
3608   if (!SWIG_IsOK(res1)) {
3609     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_name" "', argument " "1"" of type '" "tdb *""'"); 
3610   }
3611   arg1 = (tdb *)(argp1);
3612   result = (char *)tdb_name(arg1);
3613   resultobj = SWIG_FromCharPtr((const char *)result);
3614   return resultobj;
3615 fail:
3616   return NULL;
3617 }
3618
3619
3620 SWIGINTERN PyObject *Tdb_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3621   PyObject *obj;
3622   if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3623   SWIG_TypeNewClientData(SWIGTYPE_p_tdb_context, SWIG_NewClientData(obj));
3624   return SWIG_Py_Void();
3625 }
3626
3627 SWIGINTERN PyObject *Tdb_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3628   return SWIG_Python_InitShadowInstance(args);
3629 }
3630
3631 static PyMethodDef SwigMethods[] = {
3632          { (char *)"new_Tdb", (PyCFunction) _wrap_new_Tdb, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
3633                 "S.__init__(name,hash_size=0,tdb_flags=TDB_DEFAULT,flags=O_RDWR,mode=0600)\n"
3634                 "Open a TDB file.\n"
3635                 ""},
3636          { (char *)"Tdb_error", (PyCFunction)_wrap_Tdb_error, METH_O, (char *)"\n"
3637                 "S.error() -> int\n"
3638                 "Find last error number returned by operation on this TDB.\n"
3639                 ""},
3640          { (char *)"delete_Tdb", (PyCFunction)_wrap_delete_Tdb, METH_O, NULL},
3641          { (char *)"Tdb_close", (PyCFunction)_wrap_Tdb_close, METH_O, (char *)"\n"
3642                 "S.close() -> None\n"
3643                 "Close the TDB file.\n"
3644                 ""},
3645          { (char *)"Tdb_append", (PyCFunction) _wrap_Tdb_append, METH_VARARGS | METH_KEYWORDS, NULL},
3646          { (char *)"Tdb_errorstr", (PyCFunction)_wrap_Tdb_errorstr, METH_O, (char *)"\n"
3647                 "S.errorstr() -> errorstring\n"
3648                 "Obtain last error message.\n"
3649                 ""},
3650          { (char *)"Tdb_get", (PyCFunction) _wrap_Tdb_get, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
3651                 "S.fetch(key) -> value\n"
3652                 "Fetch a value.\n"
3653                 ""},
3654          { (char *)"Tdb_delete", (PyCFunction) _wrap_Tdb_delete, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
3655                 "S.delete(key) -> None\n"
3656                 "Delete an entry.\n"
3657                 ""},
3658          { (char *)"Tdb_store", (PyCFunction) _wrap_Tdb_store, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
3659                 "S.store(key, value, flag=TDB_REPLACE) -> None\n"
3660                 "Store an entry.\n"
3661                 ""},
3662          { (char *)"Tdb_exists", (PyCFunction) _wrap_Tdb_exists, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
3663                 "S.exists(key) -> bool\n"
3664                 "Check whether key exists in this database.\n"
3665                 ""},
3666          { (char *)"Tdb_firstkey", (PyCFunction)_wrap_Tdb_firstkey, METH_O, (char *)"\n"
3667                 "S.firstkey() -> data\n"
3668                 "Return the first key in this database.\n"
3669                 ""},
3670          { (char *)"Tdb_nextkey", (PyCFunction) _wrap_Tdb_nextkey, METH_VARARGS | METH_KEYWORDS, (char *)"\n"
3671                 "S.nextkey(prev) -> data\n"
3672                 "Return the next key in this database.\n"
3673                 ""},
3674          { (char *)"Tdb_lock_all", (PyCFunction)_wrap_Tdb_lock_all, METH_O, (char *)"S.lockall() -> bool"},
3675          { (char *)"Tdb_unlock_all", (PyCFunction)_wrap_Tdb_unlock_all, METH_O, (char *)"S.unlockall() -> bool"},
3676          { (char *)"Tdb_read_lock_all", (PyCFunction)_wrap_Tdb_read_lock_all, METH_O, NULL},
3677          { (char *)"Tdb_read_unlock_all", (PyCFunction)_wrap_Tdb_read_unlock_all, METH_O, NULL},
3678          { (char *)"Tdb_reopen", (PyCFunction)_wrap_Tdb_reopen, METH_O, (char *)"\n"
3679                 "S.reopen() -> bool\n"
3680                 "Reopen this file.\n"
3681                 ""},
3682          { (char *)"Tdb_transaction_start", (PyCFunction)_wrap_Tdb_transaction_start, METH_O, (char *)"\n"
3683                 "S.transaction_start() -> None\n"
3684                 "Start a new transaction.\n"
3685                 ""},
3686          { (char *)"Tdb_transaction_commit", (PyCFunction)_wrap_Tdb_transaction_commit, METH_O, (char *)"\n"
3687                 "S.transaction_commit() -> None\n"
3688                 "Commit the currently active transaction.\n"
3689                 ""},
3690          { (char *)"Tdb_transaction_cancel", (PyCFunction)_wrap_Tdb_transaction_cancel, METH_O, (char *)"\n"
3691                 "S.transaction_cancel() -> None\n"
3692                 "Cancel the currently active transaction.\n"
3693                 ""},
3694          { (char *)"Tdb_transaction_recover", (PyCFunction)_wrap_Tdb_transaction_recover, METH_O, NULL},
3695          { (char *)"Tdb_hash_size", (PyCFunction)_wrap_Tdb_hash_size, METH_O, (char *)"S.hash_size() -> int"},
3696          { (char *)"Tdb_map_size", (PyCFunction)_wrap_Tdb_map_size, METH_O, (char *)"S.map_size() -> int"},
3697          { (char *)"Tdb_get_flags", (PyCFunction)_wrap_Tdb_get_flags, METH_O, (char *)"S.get_flags() -> int"},
3698          { (char *)"Tdb_set_max_dead", (PyCFunction) _wrap_Tdb_set_max_dead, METH_VARARGS | METH_KEYWORDS, (char *)"S.set_max_dead(int) -> None"},
3699          { (char *)"Tdb_name", (PyCFunction)_wrap_Tdb_name, METH_O, (char *)"\n"
3700                 "S.name() -> path\n"
3701                 "Return filename of this TDB file.\n"
3702                 ""},
3703          { (char *)"Tdb_swigregister", Tdb_swigregister, METH_VARARGS, NULL},
3704          { (char *)"Tdb_swiginit", Tdb_swiginit, METH_VARARGS, NULL},
3705          { NULL, NULL, 0, NULL }
3706 };
3707
3708
3709 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3710
3711 static swig_type_info _swigt__p_TDB_DATA = {"_p_TDB_DATA", "TDB_DATA *", 0, 0, (void*)0, 0};
3712 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
3713 static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *|mode_t *", 0, 0, (void*)0, 0};
3714 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};
3715 static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
3716 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};
3717 static swig_type_info _swigt__p_tdb_context = {"_p_tdb_context", "struct tdb_context *|tdb *", 0, 0, (void*)0, 0};
3718 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};
3719 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};
3720 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};
3721 static swig_type_info