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