xref: /netbsd-src/crypto/external/bsd/netpgp/dist/bindings/python/netpgppython_wrap.c (revision 62a8debe1dc62962e18a1c918def78666141273b)
1 /* ----------------------------------------------------------------------------
2  * This file was automatically generated by SWIG (http://www.swig.org).
3  * Version 1.3.31
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_DIRECTOR_NO_VTABLE
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)
21 #   if (__SUNPRO_CC <= 0x560)
22 #     define SWIGTEMPLATEDISAMBIGUATOR template
23 #   else
24 #     define SWIGTEMPLATEDISAMBIGUATOR
25 #   endif
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 
111 /* Python.h has to appear first */
112 #include <Python.h>
113 
114 /* -----------------------------------------------------------------------------
115  * swigrun.swg
116  *
117  * This file contains generic CAPI SWIG runtime support for pointer
118  * type checking.
119  * ----------------------------------------------------------------------------- */
120 
121 /* This should only be incremented when either the layout of swig_type_info changes,
122    or for whatever reason, the runtime changes incompatibly */
123 #define SWIG_RUNTIME_VERSION "3"
124 
125 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
126 #ifdef SWIG_TYPE_TABLE
127 # define SWIG_QUOTE_STRING(x) #x
128 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
129 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
130 #else
131 # define SWIG_TYPE_TABLE_NAME
132 #endif
133 
134 /*
135   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
136   creating a static or dynamic library from the swig runtime code.
137   In 99.9% of the cases, swig just needs to declare them as 'static'.
138 
139   But only do this if is strictly necessary, ie, if you have problems
140   with your compiler or so.
141 */
142 
143 #ifndef SWIGRUNTIME
144 # define SWIGRUNTIME SWIGINTERN
145 #endif
146 
147 #ifndef SWIGRUNTIMEINLINE
148 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
149 #endif
150 
151 /*  Generic buffer size */
152 #ifndef SWIG_BUFFER_SIZE
153 # define SWIG_BUFFER_SIZE 1024
154 #endif
155 
156 /* Flags for pointer conversions */
157 #define SWIG_POINTER_DISOWN        0x1
158 
159 /* Flags for new pointer objects */
160 #define SWIG_POINTER_OWN           0x1
161 
162 
163 /*
164    Flags/methods for returning states.
165 
166    The swig conversion methods, as ConvertPtr, return and integer
167    that tells if the conversion was successful or not. And if not,
168    an error code can be returned (see swigerrors.swg for the codes).
169 
170    Use the following macros/flags to set or process the returning
171    states.
172 
173    In old swig versions, you usually write code as:
174 
175      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
176        // success code
177      } else {
178        //fail code
179      }
180 
181    Now you can be more explicit as:
182 
183     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
184     if (SWIG_IsOK(res)) {
185       // success code
186     } else {
187       // fail code
188     }
189 
190    that seems to be the same, but now you can also do
191 
192     Type *ptr;
193     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
194     if (SWIG_IsOK(res)) {
195       // success code
196       if (SWIG_IsNewObj(res) {
197         ...
198 	delete *ptr;
199       } else {
200         ...
201       }
202     } else {
203       // fail code
204     }
205 
206    I.e., now SWIG_ConvertPtr can return new objects and you can
207    identify the case and take care of the deallocation. Of course that
208    requires also to SWIG_ConvertPtr to return new result values, as
209 
210       int SWIG_ConvertPtr(obj, ptr,...) {
211         if (<obj is ok>) {
212           if (<need new object>) {
213             *ptr = <ptr to new allocated object>;
214             return SWIG_NEWOBJ;
215           } else {
216             *ptr = <ptr to old object>;
217             return SWIG_OLDOBJ;
218           }
219         } else {
220           return SWIG_BADOBJ;
221         }
222       }
223 
224    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
225    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
226    swig errors code.
227 
228    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
229    allows to return the 'cast rank', for example, if you have this
230 
231        int food(double)
232        int fooi(int);
233 
234    and you call
235 
236       food(1)   // cast rank '1'  (1 -> 1.0)
237       fooi(1)   // cast rank '0'
238 
239    just use the SWIG_AddCast()/SWIG_CheckState()
240 
241 
242  */
243 #define SWIG_OK                    (0)
244 #define SWIG_ERROR                 (-1)
245 #define SWIG_IsOK(r)               (r >= 0)
246 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
247 
248 /* The CastRankLimit says how many bits are used for the cast rank */
249 #define SWIG_CASTRANKLIMIT         (1 << 8)
250 /* The NewMask denotes the object was created (using new/malloc) */
251 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
252 /* The TmpMask is for in/out typemaps that use temporal objects */
253 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
254 /* Simple returning values */
255 #define SWIG_BADOBJ                (SWIG_ERROR)
256 #define SWIG_OLDOBJ                (SWIG_OK)
257 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
258 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
259 /* Check, add and del mask methods */
260 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
261 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
262 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
263 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
264 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
265 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
266 
267 
268 /* Cast-Rank Mode */
269 #if defined(SWIG_CASTRANK_MODE)
270 #  ifndef SWIG_TypeRank
271 #    define SWIG_TypeRank             unsigned long
272 #  endif
273 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
274 #    define SWIG_MAXCASTRANK          (2)
275 #  endif
276 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
277 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
278 SWIGINTERNINLINE int SWIG_AddCast(int r) {
279   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
280 }
281 SWIGINTERNINLINE int SWIG_CheckState(int r) {
282   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
283 }
284 #else /* no cast-rank mode */
285 #  define SWIG_AddCast
286 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
287 #endif
288 
289 
290 
291 
292 #include <string.h>
293 
294 #ifdef __cplusplus
295 extern "C" {
296 #endif
297 
298 typedef void *(*swig_converter_func)(void *);
299 typedef struct swig_type_info *(*swig_dycast_func)(void **);
300 
301 /* Structure to store inforomation on one type */
302 typedef struct swig_type_info {
303   const char             *name;			/* mangled name of this type */
304   const char             *str;			/* human readable name of this type */
305   swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
306   struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
307   void                   *clientdata;		/* language specific type data */
308   int                    owndata;		/* flag if the structure owns the clientdata */
309 } swig_type_info;
310 
311 /* Structure to store a type and conversion function used for casting */
312 typedef struct swig_cast_info {
313   swig_type_info         *type;			/* pointer to type that is equivalent to this type */
314   swig_converter_func     converter;		/* function to cast the void pointers */
315   struct swig_cast_info  *next;			/* pointer to next cast in linked list */
316   struct swig_cast_info  *prev;			/* pointer to the previous cast */
317 } swig_cast_info;
318 
319 /* Structure used to store module information
320  * Each module generates one structure like this, and the runtime collects
321  * all of these structures and stores them in a circularly linked list.*/
322 typedef struct swig_module_info {
323   swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
324   size_t                 size;		        /* Number of types in this module */
325   struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
326   swig_type_info         **type_initial;	/* Array of initially generated type structures */
327   swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
328   void                    *clientdata;		/* Language specific module data */
329 } swig_module_info;
330 
331 /*
332   Compare two type names skipping the space characters, therefore
333   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
334 
335   Return 0 when the two name types are equivalent, as in
336   strncmp, but skipping ' '.
337 */
338 SWIGRUNTIME int
339 SWIG_TypeNameComp(const char *f1, const char *l1,
340 		  const char *f2, const char *l2) {
341   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
342     while ((*f1 == ' ') && (f1 != l1)) ++f1;
343     while ((*f2 == ' ') && (f2 != l2)) ++f2;
344     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
345   }
346   return (l1 - f1) - (l2 - f2);
347 }
348 
349 /*
350   Check type equivalence in a name list like <name1>|<name2>|...
351   Return 0 if not equal, 1 if equal
352 */
353 SWIGRUNTIME int
354 SWIG_TypeEquiv(const char *nb, const char *tb) {
355   int equiv = 0;
356   const char* te = tb + strlen(tb);
357   const char* ne = nb;
358   while (!equiv && *ne) {
359     for (nb = ne; *ne; ++ne) {
360       if (*ne == '|') break;
361     }
362     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
363     if (*ne) ++ne;
364   }
365   return equiv;
366 }
367 
368 /*
369   Check type equivalence in a name list like <name1>|<name2>|...
370   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
371 */
372 SWIGRUNTIME int
373 SWIG_TypeCompare(const char *nb, const char *tb) {
374   int equiv = 0;
375   const char* te = tb + strlen(tb);
376   const char* ne = nb;
377   while (!equiv && *ne) {
378     for (nb = ne; *ne; ++ne) {
379       if (*ne == '|') break;
380     }
381     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
382     if (*ne) ++ne;
383   }
384   return equiv;
385 }
386 
387 
388 /* think of this as a c++ template<> or a scheme macro */
389 #define SWIG_TypeCheck_Template(comparison, ty)         \
390   if (ty) {                                             \
391     swig_cast_info *iter = ty->cast;                    \
392     while (iter) {                                      \
393       if (comparison) {                                 \
394         if (iter == ty->cast) return iter;              \
395         /* Move iter to the top of the linked list */   \
396         iter->prev->next = iter->next;                  \
397         if (iter->next)                                 \
398           iter->next->prev = iter->prev;                \
399         iter->next = ty->cast;                          \
400         iter->prev = 0;                                 \
401         if (ty->cast) ty->cast->prev = iter;            \
402         ty->cast = iter;                                \
403         return iter;                                    \
404       }                                                 \
405       iter = iter->next;                                \
406     }                                                   \
407   }                                                     \
408   return 0
409 
410 /*
411   Check the typename
412 */
413 SWIGRUNTIME swig_cast_info *
414 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
415   SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
416 }
417 
418 /* Same as previous function, except strcmp is replaced with a pointer comparison */
419 SWIGRUNTIME swig_cast_info *
420 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
421   SWIG_TypeCheck_Template(iter->type == from, into);
422 }
423 
424 /*
425   Cast a pointer up an inheritance hierarchy
426 */
427 SWIGRUNTIMEINLINE void *
428 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
429   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
430 }
431 
432 /*
433    Dynamic pointer casting. Down an inheritance hierarchy
434 */
435 SWIGRUNTIME swig_type_info *
436 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
437   swig_type_info *lastty = ty;
438   if (!ty || !ty->dcast) return ty;
439   while (ty && (ty->dcast)) {
440     ty = (*ty->dcast)(ptr);
441     if (ty) lastty = ty;
442   }
443   return lastty;
444 }
445 
446 /*
447   Return the name associated with this type
448 */
449 SWIGRUNTIMEINLINE const char *
450 SWIG_TypeName(const swig_type_info *ty) {
451   return ty->name;
452 }
453 
454 /*
455   Return the pretty name associated with this type,
456   that is an unmangled type name in a form presentable to the user.
457 */
458 SWIGRUNTIME const char *
459 SWIG_TypePrettyName(const swig_type_info *type) {
460   /* The "str" field contains the equivalent pretty names of the
461      type, separated by vertical-bar characters.  We choose
462      to print the last name, as it is often (?) the most
463      specific. */
464   if (!type) return NULL;
465   if (type->str != NULL) {
466     const char *last_name = type->str;
467     const char *s;
468     for (s = type->str; *s; s++)
469       if (*s == '|') last_name = s+1;
470     return last_name;
471   }
472   else
473     return type->name;
474 }
475 
476 /*
477    Set the clientdata field for a type
478 */
479 SWIGRUNTIME void
480 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
481   swig_cast_info *cast = ti->cast;
482   /* if (ti->clientdata == clientdata) return; */
483   ti->clientdata = clientdata;
484 
485   while (cast) {
486     if (!cast->converter) {
487       swig_type_info *tc = cast->type;
488       if (!tc->clientdata) {
489 	SWIG_TypeClientData(tc, clientdata);
490       }
491     }
492     cast = cast->next;
493   }
494 }
495 SWIGRUNTIME void
496 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
497   SWIG_TypeClientData(ti, clientdata);
498   ti->owndata = 1;
499 }
500 
501 /*
502   Search for a swig_type_info structure only by mangled name
503   Search is a O(log #types)
504 
505   We start searching at module start, and finish searching when start == end.
506   Note: if start == end at the beginning of the function, we go all the way around
507   the circular list.
508 */
509 SWIGRUNTIME swig_type_info *
510 SWIG_MangledTypeQueryModule(swig_module_info *start,
511                             swig_module_info *end,
512 		            const char *name) {
513   swig_module_info *iter = start;
514   do {
515     if (iter->size) {
516       register size_t l = 0;
517       register size_t r = iter->size - 1;
518       do {
519 	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
520 	register size_t i = (l + r) >> 1;
521 	const char *iname = iter->types[i]->name;
522 	if (iname) {
523 	  register int compare = strcmp(name, iname);
524 	  if (compare == 0) {
525 	    return iter->types[i];
526 	  } else if (compare < 0) {
527 	    if (i) {
528 	      r = i - 1;
529 	    } else {
530 	      break;
531 	    }
532 	  } else if (compare > 0) {
533 	    l = i + 1;
534 	  }
535 	} else {
536 	  break; /* should never happen */
537 	}
538       } while (l <= r);
539     }
540     iter = iter->next;
541   } while (iter != end);
542   return 0;
543 }
544 
545 /*
546   Search for a swig_type_info structure for either a mangled name or a human readable name.
547   It first searches the mangled names of the types, which is a O(log #types)
548   If a type is not found it then searches the human readable names, which is O(#types).
549 
550   We start searching at module start, and finish searching when start == end.
551   Note: if start == end at the beginning of the function, we go all the way around
552   the circular list.
553 */
554 SWIGRUNTIME swig_type_info *
555 SWIG_TypeQueryModule(swig_module_info *start,
556                      swig_module_info *end,
557 		     const char *name) {
558   /* STEP 1: Search the name field using binary search */
559   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
560   if (ret) {
561     return ret;
562   } else {
563     /* STEP 2: If the type hasn't been found, do a complete search
564        of the str field (the human readable name) */
565     swig_module_info *iter = start;
566     do {
567       register size_t i = 0;
568       for (; i < iter->size; ++i) {
569 	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
570 	  return iter->types[i];
571       }
572       iter = iter->next;
573     } while (iter != end);
574   }
575 
576   /* neither found a match */
577   return 0;
578 }
579 
580 /*
581    Pack binary data into a string
582 */
583 SWIGRUNTIME char *
584 SWIG_PackData(char *c, void *ptr, size_t sz) {
585   static const char hex[17] = "0123456789abcdef";
586   register const unsigned char *u = (unsigned char *) ptr;
587   register const unsigned char *eu =  u + sz;
588   for (; u != eu; ++u) {
589     register unsigned char uu = *u;
590     *(c++) = hex[(uu & 0xf0) >> 4];
591     *(c++) = hex[uu & 0xf];
592   }
593   return c;
594 }
595 
596 /*
597    Unpack binary data from a string
598 */
599 SWIGRUNTIME const char *
600 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
601   register unsigned char *u = (unsigned char *) ptr;
602   register const unsigned char *eu = u + sz;
603   for (; u != eu; ++u) {
604     register char d = *(c++);
605     register unsigned char uu;
606     if ((d >= '0') && (d <= '9'))
607       uu = ((d - '0') << 4);
608     else if ((d >= 'a') && (d <= 'f'))
609       uu = ((d - ('a'-10)) << 4);
610     else
611       return (char *) 0;
612     d = *(c++);
613     if ((d >= '0') && (d <= '9'))
614       uu |= (d - '0');
615     else if ((d >= 'a') && (d <= 'f'))
616       uu |= (d - ('a'-10));
617     else
618       return (char *) 0;
619     *u = uu;
620   }
621   return c;
622 }
623 
624 /*
625    Pack 'void *' into a string buffer.
626 */
627 SWIGRUNTIME char *
628 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
629   char *r = buff;
630   if ((2*sizeof(void *) + 2) > bsz) return 0;
631   *(r++) = '_';
632   r = SWIG_PackData(r,&ptr,sizeof(void *));
633   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
634   strcpy(r,name);
635   return buff;
636 }
637 
638 SWIGRUNTIME const char *
639 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
640   if (*c != '_') {
641     if (strcmp(c,"NULL") == 0) {
642       *ptr = (void *) 0;
643       return name;
644     } else {
645       return 0;
646     }
647   }
648   return SWIG_UnpackData(++c,ptr,sizeof(void *));
649 }
650 
651 SWIGRUNTIME char *
652 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
653   char *r = buff;
654   size_t lname = (name ? strlen(name) : 0);
655   if ((2*sz + 2 + lname) > bsz) return 0;
656   *(r++) = '_';
657   r = SWIG_PackData(r,ptr,sz);
658   if (lname) {
659     strncpy(r,name,lname+1);
660   } else {
661     *r = 0;
662   }
663   return buff;
664 }
665 
666 SWIGRUNTIME const char *
667 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
668   if (*c != '_') {
669     if (strcmp(c,"NULL") == 0) {
670       memset(ptr,0,sz);
671       return name;
672     } else {
673       return 0;
674     }
675   }
676   return SWIG_UnpackData(++c,ptr,sz);
677 }
678 
679 #ifdef __cplusplus
680 }
681 #endif
682 
683 /*  Errors in SWIG */
684 #define  SWIG_UnknownError    	   -1
685 #define  SWIG_IOError        	   -2
686 #define  SWIG_RuntimeError   	   -3
687 #define  SWIG_IndexError     	   -4
688 #define  SWIG_TypeError      	   -5
689 #define  SWIG_DivisionByZero 	   -6
690 #define  SWIG_OverflowError  	   -7
691 #define  SWIG_SyntaxError    	   -8
692 #define  SWIG_ValueError     	   -9
693 #define  SWIG_SystemError    	   -10
694 #define  SWIG_AttributeError 	   -11
695 #define  SWIG_MemoryError    	   -12
696 #define  SWIG_NullReferenceError   -13
697 
698 
699 
700 
701 /* Add PyOS_snprintf for old Pythons */
702 #if PY_VERSION_HEX < 0x02020000
703 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
704 #  define PyOS_snprintf _snprintf
705 # else
706 #  define PyOS_snprintf snprintf
707 # endif
708 #endif
709 
710 /* A crude PyString_FromFormat implementation for old Pythons */
711 #if PY_VERSION_HEX < 0x02020000
712 
713 #ifndef SWIG_PYBUFFER_SIZE
714 # define SWIG_PYBUFFER_SIZE 1024
715 #endif
716 
717 static PyObject *
718 PyString_FromFormat(const char *fmt, ...) {
719   va_list ap;
720   char buf[SWIG_PYBUFFER_SIZE * 2];
721   int res;
722   va_start(ap, fmt);
723   res = vsnprintf(buf, sizeof(buf), fmt, ap);
724   va_end(ap);
725   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
726 }
727 #endif
728 
729 /* Add PyObject_Del for old Pythons */
730 #if PY_VERSION_HEX < 0x01060000
731 # define PyObject_Del(op) PyMem_DEL((op))
732 #endif
733 #ifndef PyObject_DEL
734 # define PyObject_DEL PyObject_Del
735 #endif
736 
737 /* A crude PyExc_StopIteration exception for old Pythons */
738 #if PY_VERSION_HEX < 0x02020000
739 # ifndef PyExc_StopIteration
740 #  define PyExc_StopIteration PyExc_RuntimeError
741 # endif
742 # ifndef PyObject_GenericGetAttr
743 #  define PyObject_GenericGetAttr 0
744 # endif
745 #endif
746 /* Py_NotImplemented is defined in 2.1 and up. */
747 #if PY_VERSION_HEX < 0x02010000
748 # ifndef Py_NotImplemented
749 #  define Py_NotImplemented PyExc_RuntimeError
750 # endif
751 #endif
752 
753 
754 /* A crude PyString_AsStringAndSize implementation for old Pythons */
755 #if PY_VERSION_HEX < 0x02010000
756 # ifndef PyString_AsStringAndSize
757 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
758 # endif
759 #endif
760 
761 /* PySequence_Size for old Pythons */
762 #if PY_VERSION_HEX < 0x02000000
763 # ifndef PySequence_Size
764 #  define PySequence_Size PySequence_Length
765 # endif
766 #endif
767 
768 
769 /* PyBool_FromLong for old Pythons */
770 #if PY_VERSION_HEX < 0x02030000
771 static
772 PyObject *PyBool_FromLong(long ok)
773 {
774   PyObject *result = ok ? Py_True : Py_False;
775   Py_INCREF(result);
776   return result;
777 }
778 #endif
779 
780 /* Py_ssize_t for old Pythons */
781 /* This code is as recommended by: */
782 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
783 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
784 typedef int Py_ssize_t;
785 # define PY_SSIZE_T_MAX INT_MAX
786 # define PY_SSIZE_T_MIN INT_MIN
787 #endif
788 
789 /* -----------------------------------------------------------------------------
790  * error manipulation
791  * ----------------------------------------------------------------------------- */
792 
793 SWIGRUNTIME PyObject*
794 SWIG_Python_ErrorType(int code) {
795   PyObject* type = 0;
796   switch(code) {
797   case SWIG_MemoryError:
798     type = PyExc_MemoryError;
799     break;
800   case SWIG_IOError:
801     type = PyExc_IOError;
802     break;
803   case SWIG_RuntimeError:
804     type = PyExc_RuntimeError;
805     break;
806   case SWIG_IndexError:
807     type = PyExc_IndexError;
808     break;
809   case SWIG_TypeError:
810     type = PyExc_TypeError;
811     break;
812   case SWIG_DivisionByZero:
813     type = PyExc_ZeroDivisionError;
814     break;
815   case SWIG_OverflowError:
816     type = PyExc_OverflowError;
817     break;
818   case SWIG_SyntaxError:
819     type = PyExc_SyntaxError;
820     break;
821   case SWIG_ValueError:
822     type = PyExc_ValueError;
823     break;
824   case SWIG_SystemError:
825     type = PyExc_SystemError;
826     break;
827   case SWIG_AttributeError:
828     type = PyExc_AttributeError;
829     break;
830   default:
831     type = PyExc_RuntimeError;
832   }
833   return type;
834 }
835 
836 
837 SWIGRUNTIME void
838 SWIG_Python_AddErrorMsg(const char* mesg)
839 {
840   PyObject *type = 0;
841   PyObject *value = 0;
842   PyObject *traceback = 0;
843 
844   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
845   if (value) {
846     PyObject *old_str = PyObject_Str(value);
847     PyErr_Clear();
848     Py_XINCREF(type);
849     PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
850     Py_DECREF(old_str);
851     Py_DECREF(value);
852   } else {
853     PyErr_Format(PyExc_RuntimeError, mesg);
854   }
855 }
856 
857 
858 
859 #if defined(SWIG_PYTHON_NO_THREADS)
860 #  if defined(SWIG_PYTHON_THREADS)
861 #    undef SWIG_PYTHON_THREADS
862 #  endif
863 #endif
864 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
865 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
866 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
867 #      define SWIG_PYTHON_USE_GIL
868 #    endif
869 #  endif
870 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
871 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
872 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads()
873 #    endif
874 #    ifdef __cplusplus /* C++ code */
875        class SWIG_Python_Thread_Block {
876          bool status;
877          PyGILState_STATE state;
878        public:
879          void end() { if (status) { PyGILState_Release(state); status = false;} }
880          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
881          ~SWIG_Python_Thread_Block() { end(); }
882        };
883        class SWIG_Python_Thread_Allow {
884          bool status;
885          PyThreadState *save;
886        public:
887          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
888          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
889          ~SWIG_Python_Thread_Allow() { end(); }
890        };
891 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
892 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
893 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
894 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
895 #    else /* C code */
896 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
897 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
898 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
899 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
900 #    endif
901 #  else /* Old thread way, not implemented, user must provide it */
902 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
903 #      define SWIG_PYTHON_INITIALIZE_THREADS
904 #    endif
905 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
906 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
907 #    endif
908 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
909 #      define SWIG_PYTHON_THREAD_END_BLOCK
910 #    endif
911 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
912 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
913 #    endif
914 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
915 #      define SWIG_PYTHON_THREAD_END_ALLOW
916 #    endif
917 #  endif
918 #else /* No thread support */
919 #  define SWIG_PYTHON_INITIALIZE_THREADS
920 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
921 #  define SWIG_PYTHON_THREAD_END_BLOCK
922 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
923 #  define SWIG_PYTHON_THREAD_END_ALLOW
924 #endif
925 
926 /* -----------------------------------------------------------------------------
927  * Python API portion that goes into the runtime
928  * ----------------------------------------------------------------------------- */
929 
930 #ifdef __cplusplus
931 extern "C" {
932 #if 0
933 } /* cc-mode */
934 #endif
935 #endif
936 
937 /* -----------------------------------------------------------------------------
938  * Constant declarations
939  * ----------------------------------------------------------------------------- */
940 
941 /* Constant Types */
942 #define SWIG_PY_POINTER 4
943 #define SWIG_PY_BINARY  5
944 
945 /* Constant information structure */
946 typedef struct swig_const_info {
947   int type;
948   char *name;
949   long lvalue;
950   double dvalue;
951   void   *pvalue;
952   swig_type_info **ptype;
953 } swig_const_info;
954 
955 #ifdef __cplusplus
956 #if 0
957 { /* cc-mode */
958 #endif
959 }
960 #endif
961 
962 
963 /* -----------------------------------------------------------------------------
964  * See the LICENSE file for information on copyright, usage and redistribution
965  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
966  *
967  * pyrun.swg
968  *
969  * This file contains the runtime support for Python modules
970  * and includes code for managing global variables and pointer
971  * type checking.
972  *
973  * ----------------------------------------------------------------------------- */
974 
975 /* Common SWIG API */
976 
977 /* for raw pointers */
978 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
979 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
980 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
981 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
982 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty)
983 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
984 #define swig_owntype                                    int
985 
986 /* for raw packed data */
987 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
988 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
989 
990 /* for class or struct pointers */
991 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
992 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
993 
994 /* for C or C++ function pointers */
995 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
996 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
997 
998 /* for C++ member pointers, ie, member methods */
999 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1000 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1001 
1002 
1003 /* Runtime API */
1004 
1005 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1006 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1007 #define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
1008 
1009 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
1010 #define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg
1011 #define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)
1012 #define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1013 #define SWIG_fail                        		goto fail
1014 
1015 
1016 /* Runtime API implementation */
1017 
1018 /* Error manipulation */
1019 
1020 SWIGINTERN void
1021 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1022   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1023   PyErr_SetObject(errtype, obj);
1024   Py_DECREF(obj);
1025   SWIG_PYTHON_THREAD_END_BLOCK;
1026 }
1027 
1028 SWIGINTERN void
1029 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1030   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1031   PyErr_SetString(errtype, (char *) msg);
1032   SWIG_PYTHON_THREAD_END_BLOCK;
1033 }
1034 
1035 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1036 
1037 /* Set a constant value */
1038 
1039 SWIGINTERN void
1040 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1041   PyDict_SetItemString(d, (char*) name, obj);
1042   Py_DECREF(obj);
1043 }
1044 
1045 /* Append a value to the result obj */
1046 
1047 SWIGINTERN PyObject*
1048 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1049 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1050   if (!result) {
1051     result = obj;
1052   } else if (result == Py_None) {
1053     Py_DECREF(result);
1054     result = obj;
1055   } else {
1056     if (!PyList_Check(result)) {
1057       PyObject *o2 = result;
1058       result = PyList_New(1);
1059       PyList_SetItem(result, 0, o2);
1060     }
1061     PyList_Append(result,obj);
1062     Py_DECREF(obj);
1063   }
1064   return result;
1065 #else
1066   PyObject*   o2;
1067   PyObject*   o3;
1068   if (!result) {
1069     result = obj;
1070   } else if (result == Py_None) {
1071     Py_DECREF(result);
1072     result = obj;
1073   } else {
1074     if (!PyTuple_Check(result)) {
1075       o2 = result;
1076       result = PyTuple_New(1);
1077       PyTuple_SET_ITEM(result, 0, o2);
1078     }
1079     o3 = PyTuple_New(1);
1080     PyTuple_SET_ITEM(o3, 0, obj);
1081     o2 = result;
1082     result = PySequence_Concat(o2, o3);
1083     Py_DECREF(o2);
1084     Py_DECREF(o3);
1085   }
1086   return result;
1087 #endif
1088 }
1089 
1090 /* Unpack the argument tuple */
1091 
1092 SWIGINTERN int
1093 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1094 {
1095   if (!args) {
1096     if (!min && !max) {
1097       return 1;
1098     } else {
1099       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1100 		   name, (min == max ? "" : "at least "), min);
1101       return 0;
1102     }
1103   }
1104   if (!PyTuple_Check(args)) {
1105     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1106     return 0;
1107   } else {
1108     register int l = PyTuple_GET_SIZE(args);
1109     if (l < min) {
1110       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1111 		   name, (min == max ? "" : "at least "), min, l);
1112       return 0;
1113     } else if (l > max) {
1114       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1115 		   name, (min == max ? "" : "at most "), max, l);
1116       return 0;
1117     } else {
1118       register int i;
1119       for (i = 0; i < l; ++i) {
1120 	objs[i] = PyTuple_GET_ITEM(args, i);
1121       }
1122       for (; l < max; ++l) {
1123 	objs[l] = 0;
1124       }
1125       return i + 1;
1126     }
1127   }
1128 }
1129 
1130 /* A functor is a function object with one single object argument */
1131 #if PY_VERSION_HEX >= 0x02020000
1132 #define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);
1133 #else
1134 #define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunction(functor, "O", obj);
1135 #endif
1136 
1137 /*
1138   Helper for static pointer initialization for both C and C++ code, for example
1139   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1140 */
1141 #ifdef __cplusplus
1142 #define SWIG_STATIC_POINTER(var)  var
1143 #else
1144 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1145 #endif
1146 
1147 /* -----------------------------------------------------------------------------
1148  * Pointer declarations
1149  * ----------------------------------------------------------------------------- */
1150 
1151 /* Flags for new pointer objects */
1152 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
1153 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1154 
1155 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1156 
1157 #ifdef __cplusplus
1158 extern "C" {
1159 #if 0
1160 } /* cc-mode */
1161 #endif
1162 #endif
1163 
1164 /*  How to access Py_None */
1165 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1166 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
1167 #    ifndef SWIG_PYTHON_BUILD_NONE
1168 #      define SWIG_PYTHON_BUILD_NONE
1169 #    endif
1170 #  endif
1171 #endif
1172 
1173 #ifdef SWIG_PYTHON_BUILD_NONE
1174 #  ifdef Py_None
1175 #   undef Py_None
1176 #   define Py_None SWIG_Py_None()
1177 #  endif
1178 SWIGRUNTIMEINLINE PyObject *
1179 _SWIG_Py_None(void)
1180 {
1181   PyObject *none = Py_BuildValue((char*)"");
1182   Py_DECREF(none);
1183   return none;
1184 }
1185 SWIGRUNTIME PyObject *
1186 SWIG_Py_None(void)
1187 {
1188   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1189   return none;
1190 }
1191 #endif
1192 
1193 /* The python void return value */
1194 
1195 SWIGRUNTIMEINLINE PyObject *
1196 SWIG_Py_Void(void)
1197 {
1198   PyObject *none = Py_None;
1199   Py_INCREF(none);
1200   return none;
1201 }
1202 
1203 /* PySwigClientData */
1204 
1205 typedef struct {
1206   PyObject *klass;
1207   PyObject *newraw;
1208   PyObject *newargs;
1209   PyObject *destroy;
1210   int delargs;
1211   int implicitconv;
1212 } PySwigClientData;
1213 
1214 SWIGRUNTIMEINLINE int
1215 SWIG_Python_CheckImplicit(swig_type_info *ty)
1216 {
1217   PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1218   return data ? data->implicitconv : 0;
1219 }
1220 
1221 SWIGRUNTIMEINLINE PyObject *
1222 SWIG_Python_ExceptionType(swig_type_info *desc) {
1223   PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1224   PyObject *klass = data ? data->klass : 0;
1225   return (klass ? klass : PyExc_RuntimeError);
1226 }
1227 
1228 
1229 SWIGRUNTIME PySwigClientData *
1230 PySwigClientData_New(PyObject* obj)
1231 {
1232   if (!obj) {
1233     return 0;
1234   } else {
1235     PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1236     /* the klass element */
1237     data->klass = obj;
1238     Py_INCREF(data->klass);
1239     /* the newraw method and newargs arguments used to create a new raw instance */
1240     if (PyClass_Check(obj)) {
1241       data->newraw = 0;
1242       data->newargs = obj;
1243       Py_INCREF(obj);
1244     } else {
1245 #if (PY_VERSION_HEX < 0x02020000)
1246       data->newraw = 0;
1247 #else
1248       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1249 #endif
1250       if (data->newraw) {
1251 	Py_INCREF(data->newraw);
1252 	data->newargs = PyTuple_New(1);
1253 	PyTuple_SetItem(data->newargs, 0, obj);
1254       } else {
1255 	data->newargs = obj;
1256       }
1257       Py_INCREF(data->newargs);
1258     }
1259     /* the destroy method, aka as the C++ delete method */
1260     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1261     if (PyErr_Occurred()) {
1262       PyErr_Clear();
1263       data->destroy = 0;
1264     }
1265     if (data->destroy) {
1266       int flags;
1267       Py_INCREF(data->destroy);
1268       flags = PyCFunction_GET_FLAGS(data->destroy);
1269 #ifdef METH_O
1270       data->delargs = !(flags & (METH_O));
1271 #else
1272       data->delargs = 0;
1273 #endif
1274     } else {
1275       data->delargs = 0;
1276     }
1277     data->implicitconv = 0;
1278     return data;
1279   }
1280 }
1281 
1282 SWIGRUNTIME void
1283 PySwigClientData_Del(PySwigClientData* data)
1284 {
1285   Py_XDECREF(data->newraw);
1286   Py_XDECREF(data->newargs);
1287   Py_XDECREF(data->destroy);
1288 }
1289 
1290 /* =============== PySwigObject =====================*/
1291 
1292 typedef struct {
1293   PyObject_HEAD
1294   void *ptr;
1295   swig_type_info *ty;
1296   int own;
1297   PyObject *next;
1298 } PySwigObject;
1299 
1300 SWIGRUNTIME PyObject *
1301 PySwigObject_long(PySwigObject *v)
1302 {
1303   return PyLong_FromVoidPtr(v->ptr);
1304 }
1305 
1306 SWIGRUNTIME PyObject *
1307 PySwigObject_format(const char* fmt, PySwigObject *v)
1308 {
1309   PyObject *res = NULL;
1310   PyObject *args = PyTuple_New(1);
1311   if (args) {
1312     if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1313       PyObject *ofmt = PyString_FromString(fmt);
1314       if (ofmt) {
1315 	res = PyString_Format(ofmt,args);
1316 	Py_DECREF(ofmt);
1317       }
1318       Py_DECREF(args);
1319     }
1320   }
1321   return res;
1322 }
1323 
1324 SWIGRUNTIME PyObject *
1325 PySwigObject_oct(PySwigObject *v)
1326 {
1327   return PySwigObject_format("%o",v);
1328 }
1329 
1330 SWIGRUNTIME PyObject *
1331 PySwigObject_hex(PySwigObject *v)
1332 {
1333   return PySwigObject_format("%x",v);
1334 }
1335 
1336 SWIGRUNTIME PyObject *
1337 #ifdef METH_NOARGS
1338 PySwigObject_repr(PySwigObject *v)
1339 #else
1340 PySwigObject_repr(PySwigObject *v, PyObject *args)
1341 #endif
1342 {
1343   const char *name = SWIG_TypePrettyName(v->ty);
1344   PyObject *hex = PySwigObject_hex(v);
1345   PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1346   Py_DECREF(hex);
1347   if (v->next) {
1348 #ifdef METH_NOARGS
1349     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1350 #else
1351     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1352 #endif
1353     PyString_ConcatAndDel(&repr,nrep);
1354   }
1355   return repr;
1356 }
1357 
1358 SWIGRUNTIME int
1359 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1360 {
1361 #ifdef METH_NOARGS
1362   PyObject *repr = PySwigObject_repr(v);
1363 #else
1364   PyObject *repr = PySwigObject_repr(v, NULL);
1365 #endif
1366   if (repr) {
1367     fputs(PyString_AsString(repr), fp);
1368     Py_DECREF(repr);
1369     return 0;
1370   } else {
1371     return 1;
1372   }
1373 }
1374 
1375 SWIGRUNTIME PyObject *
1376 PySwigObject_str(PySwigObject *v)
1377 {
1378   char result[SWIG_BUFFER_SIZE];
1379   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1380     PyString_FromString(result) : 0;
1381 }
1382 
1383 SWIGRUNTIME int
1384 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1385 {
1386   void *i = v->ptr;
1387   void *j = w->ptr;
1388   return (i < j) ? -1 : ((i > j) ? 1 : 0);
1389 }
1390 
1391 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1392 
1393 SWIGRUNTIME PyTypeObject*
1394 PySwigObject_type(void) {
1395   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1396   return type;
1397 }
1398 
1399 SWIGRUNTIMEINLINE int
1400 PySwigObject_Check(PyObject *op) {
1401   return ((op)->ob_type == PySwigObject_type())
1402     || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1403 }
1404 
1405 SWIGRUNTIME PyObject *
1406 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1407 
1408 SWIGRUNTIME void
1409 PySwigObject_dealloc(PyObject *v)
1410 {
1411   PySwigObject *sobj = (PySwigObject *) v;
1412   PyObject *next = sobj->next;
1413   if (sobj->own) {
1414     swig_type_info *ty = sobj->ty;
1415     PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1416     PyObject *destroy = data ? data->destroy : 0;
1417     if (destroy) {
1418       /* destroy is always a VARARGS method */
1419       PyObject *res;
1420       if (data->delargs) {
1421 	/* we need to create a temporal object to carry the destroy operation */
1422 	PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1423 	res = SWIG_Python_CallFunctor(destroy, tmp);
1424 	Py_DECREF(tmp);
1425       } else {
1426 	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1427 	PyObject *mself = PyCFunction_GET_SELF(destroy);
1428 	res = ((*meth)(mself, v));
1429       }
1430       Py_XDECREF(res);
1431     } else {
1432       const char *name = SWIG_TypePrettyName(ty);
1433 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1434       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1435 #endif
1436     }
1437   }
1438   Py_XDECREF(next);
1439   PyObject_DEL(v);
1440 }
1441 
1442 SWIGRUNTIME PyObject*
1443 PySwigObject_append(PyObject* v, PyObject* next)
1444 {
1445   PySwigObject *sobj = (PySwigObject *) v;
1446 #ifndef METH_O
1447   PyObject *tmp = 0;
1448   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1449   next = tmp;
1450 #endif
1451   if (!PySwigObject_Check(next)) {
1452     return NULL;
1453   }
1454   sobj->next = next;
1455   Py_INCREF(next);
1456   return SWIG_Py_Void();
1457 }
1458 
1459 SWIGRUNTIME PyObject*
1460 #ifdef METH_NOARGS
1461 PySwigObject_next(PyObject* v)
1462 #else
1463 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1464 #endif
1465 {
1466   PySwigObject *sobj = (PySwigObject *) v;
1467   if (sobj->next) {
1468     Py_INCREF(sobj->next);
1469     return sobj->next;
1470   } else {
1471     return SWIG_Py_Void();
1472   }
1473 }
1474 
1475 SWIGINTERN PyObject*
1476 #ifdef METH_NOARGS
1477 PySwigObject_disown(PyObject *v)
1478 #else
1479 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1480 #endif
1481 {
1482   PySwigObject *sobj = (PySwigObject *)v;
1483   sobj->own = 0;
1484   return SWIG_Py_Void();
1485 }
1486 
1487 SWIGINTERN PyObject*
1488 #ifdef METH_NOARGS
1489 PySwigObject_acquire(PyObject *v)
1490 #else
1491 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1492 #endif
1493 {
1494   PySwigObject *sobj = (PySwigObject *)v;
1495   sobj->own = SWIG_POINTER_OWN;
1496   return SWIG_Py_Void();
1497 }
1498 
1499 SWIGINTERN PyObject*
1500 PySwigObject_own(PyObject *v, PyObject *args)
1501 {
1502   PyObject *val = 0;
1503 #if (PY_VERSION_HEX < 0x02020000)
1504   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1505 #else
1506   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1507 #endif
1508     {
1509       return NULL;
1510     }
1511   else
1512     {
1513       PySwigObject *sobj = (PySwigObject *)v;
1514       PyObject *obj = PyBool_FromLong(sobj->own);
1515       if (val) {
1516 #ifdef METH_NOARGS
1517 	if (PyObject_IsTrue(val)) {
1518 	  PySwigObject_acquire(v);
1519 	} else {
1520 	  PySwigObject_disown(v);
1521 	}
1522 #else
1523 	if (PyObject_IsTrue(val)) {
1524 	  PySwigObject_acquire(v,args);
1525 	} else {
1526 	  PySwigObject_disown(v,args);
1527 	}
1528 #endif
1529       }
1530       return obj;
1531     }
1532 }
1533 
1534 #ifdef METH_O
1535 static PyMethodDef
1536 swigobject_methods[] = {
1537   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1538   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
1539   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1540   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
1541   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1542   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1543   {0, 0, 0, 0}
1544 };
1545 #else
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1549   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1550   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1551   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1552   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1553   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1554   {0, 0, 0, 0}
1555 };
1556 #endif
1557 
1558 #if PY_VERSION_HEX < 0x02020000
1559 SWIGINTERN PyObject *
1560 PySwigObject_getattr(PySwigObject *sobj,char *name)
1561 {
1562   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1563 }
1564 #endif
1565 
1566 SWIGRUNTIME PyTypeObject*
1567 _PySwigObject_type(void) {
1568   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1569 
1570   static PyNumberMethods PySwigObject_as_number = {
1571     (binaryfunc)0, /*nb_add*/
1572     (binaryfunc)0, /*nb_subtract*/
1573     (binaryfunc)0, /*nb_multiply*/
1574     (binaryfunc)0, /*nb_divide*/
1575     (binaryfunc)0, /*nb_remainder*/
1576     (binaryfunc)0, /*nb_divmod*/
1577     (ternaryfunc)0,/*nb_power*/
1578     (unaryfunc)0,  /*nb_negative*/
1579     (unaryfunc)0,  /*nb_positive*/
1580     (unaryfunc)0,  /*nb_absolute*/
1581     (inquiry)0,    /*nb_nonzero*/
1582     0,		   /*nb_invert*/
1583     0,		   /*nb_lshift*/
1584     0,		   /*nb_rshift*/
1585     0,		   /*nb_and*/
1586     0,		   /*nb_xor*/
1587     0,		   /*nb_or*/
1588     (coercion)0,   /*nb_coerce*/
1589     (unaryfunc)PySwigObject_long, /*nb_int*/
1590     (unaryfunc)PySwigObject_long, /*nb_long*/
1591     (unaryfunc)0,                 /*nb_float*/
1592     (unaryfunc)PySwigObject_oct,  /*nb_oct*/
1593     (unaryfunc)PySwigObject_hex,  /*nb_hex*/
1594 #if PY_VERSION_HEX >= 0x02020000
1595     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1596 #elif PY_VERSION_HEX >= 0x02000000
1597     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1598 #endif
1599   };
1600 
1601   static PyTypeObject pyswigobject_type;
1602   static int type_init = 0;
1603   if (!type_init) {
1604     const PyTypeObject tmp
1605       = {
1606 	PyObject_HEAD_INIT(NULL)
1607 	0,				    /* ob_size */
1608 	(char *)"PySwigObject",		    /* tp_name */
1609 	sizeof(PySwigObject),		    /* tp_basicsize */
1610 	0,			            /* tp_itemsize */
1611 	(destructor)PySwigObject_dealloc,   /* tp_dealloc */
1612 	(printfunc)PySwigObject_print,	    /* tp_print */
1613 #if PY_VERSION_HEX < 0x02020000
1614 	(getattrfunc)PySwigObject_getattr,  /* tp_getattr */
1615 #else
1616 	(getattrfunc)0,			    /* tp_getattr */
1617 #endif
1618 	(setattrfunc)0,			    /* tp_setattr */
1619 	(cmpfunc)PySwigObject_compare,	    /* tp_compare */
1620 	(reprfunc)PySwigObject_repr,	    /* tp_repr */
1621 	&PySwigObject_as_number,	    /* tp_as_number */
1622 	0,				    /* tp_as_sequence */
1623 	0,				    /* tp_as_mapping */
1624 	(hashfunc)0,			    /* tp_hash */
1625 	(ternaryfunc)0,			    /* tp_call */
1626 	(reprfunc)PySwigObject_str,	    /* tp_str */
1627 	PyObject_GenericGetAttr,            /* tp_getattro */
1628 	0,				    /* tp_setattro */
1629 	0,		                    /* tp_as_buffer */
1630 	Py_TPFLAGS_DEFAULT,	            /* tp_flags */
1631 	swigobject_doc, 	            /* tp_doc */
1632 	0,                                  /* tp_traverse */
1633 	0,                                  /* tp_clear */
1634 	0,                                  /* tp_richcompare */
1635 	0,                                  /* tp_weaklistoffset */
1636 #if PY_VERSION_HEX >= 0x02020000
1637 	0,                                  /* tp_iter */
1638 	0,                                  /* tp_iternext */
1639 	swigobject_methods,		    /* tp_methods */
1640 	0,			            /* tp_members */
1641 	0,				    /* tp_getset */
1642 	0,			            /* tp_base */
1643 	0,				    /* tp_dict */
1644 	0,				    /* tp_descr_get */
1645 	0,				    /* tp_descr_set */
1646 	0,				    /* tp_dictoffset */
1647 	0,				    /* tp_init */
1648 	0,				    /* tp_alloc */
1649 	0,			            /* tp_new */
1650 	0,	                            /* tp_free */
1651         0,                                  /* tp_is_gc */
1652 	0,				    /* tp_bases */
1653 	0,				    /* tp_mro */
1654 	0,				    /* tp_cache */
1655  	0,				    /* tp_subclasses */
1656 	0,				    /* tp_weaklist */
1657 #endif
1658 #if PY_VERSION_HEX >= 0x02030000
1659 	0,                                  /* tp_del */
1660 #endif
1661 #ifdef COUNT_ALLOCS
1662 	0,0,0,0                             /* tp_alloc -> tp_next */
1663 #endif
1664       };
1665     pyswigobject_type = tmp;
1666     pyswigobject_type.ob_type = &PyType_Type;
1667     type_init = 1;
1668   }
1669   return &pyswigobject_type;
1670 }
1671 
1672 SWIGRUNTIME PyObject *
1673 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1674 {
1675   PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1676   if (sobj) {
1677     sobj->ptr  = ptr;
1678     sobj->ty   = ty;
1679     sobj->own  = own;
1680     sobj->next = 0;
1681   }
1682   return (PyObject *)sobj;
1683 }
1684 
1685 /* -----------------------------------------------------------------------------
1686  * Implements a simple Swig Packed type, and use it instead of string
1687  * ----------------------------------------------------------------------------- */
1688 
1689 typedef struct {
1690   PyObject_HEAD
1691   void *pack;
1692   swig_type_info *ty;
1693   size_t size;
1694 } PySwigPacked;
1695 
1696 SWIGRUNTIME int
1697 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1698 {
1699   char result[SWIG_BUFFER_SIZE];
1700   fputs("<Swig Packed ", fp);
1701   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1702     fputs("at ", fp);
1703     fputs(result, fp);
1704   }
1705   fputs(v->ty->name,fp);
1706   fputs(">", fp);
1707   return 0;
1708 }
1709 
1710 SWIGRUNTIME PyObject *
1711 PySwigPacked_repr(PySwigPacked *v)
1712 {
1713   char result[SWIG_BUFFER_SIZE];
1714   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1715     return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1716   } else {
1717     return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1718   }
1719 }
1720 
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_str(PySwigPacked *v)
1723 {
1724   char result[SWIG_BUFFER_SIZE];
1725   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1726     return PyString_FromFormat("%s%s", result, v->ty->name);
1727   } else {
1728     return PyString_FromString(v->ty->name);
1729   }
1730 }
1731 
1732 SWIGRUNTIME int
1733 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1734 {
1735   size_t i = v->size;
1736   size_t j = w->size;
1737   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1738   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1739 }
1740 
1741 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1742 
1743 SWIGRUNTIME PyTypeObject*
1744 PySwigPacked_type(void) {
1745   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1746   return type;
1747 }
1748 
1749 SWIGRUNTIMEINLINE int
1750 PySwigPacked_Check(PyObject *op) {
1751   return ((op)->ob_type == _PySwigPacked_type())
1752     || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1753 }
1754 
1755 SWIGRUNTIME void
1756 PySwigPacked_dealloc(PyObject *v)
1757 {
1758   if (PySwigPacked_Check(v)) {
1759     PySwigPacked *sobj = (PySwigPacked *) v;
1760     free(sobj->pack);
1761   }
1762   PyObject_DEL(v);
1763 }
1764 
1765 SWIGRUNTIME PyTypeObject*
1766 _PySwigPacked_type(void) {
1767   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1768   static PyTypeObject pyswigpacked_type;
1769   static int type_init = 0;
1770   if (!type_init) {
1771     const PyTypeObject tmp
1772       = {
1773 	PyObject_HEAD_INIT(NULL)
1774 	0,				    /* ob_size */
1775 	(char *)"PySwigPacked",		    /* tp_name */
1776 	sizeof(PySwigPacked),		    /* tp_basicsize */
1777 	0,				    /* tp_itemsize */
1778 	(destructor)PySwigPacked_dealloc,   /* tp_dealloc */
1779 	(printfunc)PySwigPacked_print,	    /* tp_print */
1780 	(getattrfunc)0,			    /* tp_getattr */
1781 	(setattrfunc)0,			    /* tp_setattr */
1782 	(cmpfunc)PySwigPacked_compare,	    /* tp_compare */
1783 	(reprfunc)PySwigPacked_repr,	    /* tp_repr */
1784 	0,	                            /* tp_as_number */
1785 	0,				    /* tp_as_sequence */
1786 	0,				    /* tp_as_mapping */
1787 	(hashfunc)0,			    /* tp_hash */
1788 	(ternaryfunc)0,			    /* tp_call */
1789 	(reprfunc)PySwigPacked_str,	    /* tp_str */
1790 	PyObject_GenericGetAttr,            /* tp_getattro */
1791 	0,				    /* tp_setattro */
1792 	0,		                    /* tp_as_buffer */
1793 	Py_TPFLAGS_DEFAULT,	            /* tp_flags */
1794 	swigpacked_doc, 	            /* tp_doc */
1795 	0,                                  /* tp_traverse */
1796 	0,                                  /* tp_clear */
1797 	0,                                  /* tp_richcompare */
1798 	0,                                  /* tp_weaklistoffset */
1799 #if PY_VERSION_HEX >= 0x02020000
1800 	0,                                  /* tp_iter */
1801 	0,                                  /* tp_iternext */
1802 	0,		                    /* tp_methods */
1803 	0,			            /* tp_members */
1804 	0,				    /* tp_getset */
1805 	0,			            /* tp_base */
1806 	0,				    /* tp_dict */
1807 	0,				    /* tp_descr_get */
1808 	0,				    /* tp_descr_set */
1809 	0,				    /* tp_dictoffset */
1810 	0,				    /* tp_init */
1811 	0,				    /* tp_alloc */
1812 	0,			            /* tp_new */
1813 	0, 	                            /* tp_free */
1814         0,                                  /* tp_is_gc */
1815 	0,				    /* tp_bases */
1816 	0,				    /* tp_mro */
1817 	0,				    /* tp_cache */
1818  	0,				    /* tp_subclasses */
1819 	0,				    /* tp_weaklist */
1820 #endif
1821 #if PY_VERSION_HEX >= 0x02030000
1822 	0,                                  /* tp_del */
1823 #endif
1824 #ifdef COUNT_ALLOCS
1825 	0,0,0,0                             /* tp_alloc -> tp_next */
1826 #endif
1827       };
1828     pyswigpacked_type = tmp;
1829     pyswigpacked_type.ob_type = &PyType_Type;
1830     type_init = 1;
1831   }
1832   return &pyswigpacked_type;
1833 }
1834 
1835 SWIGRUNTIME PyObject *
1836 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1837 {
1838   PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1839   if (sobj) {
1840     void *pack = malloc(size);
1841     if (pack) {
1842       memcpy(pack, ptr, size);
1843       sobj->pack = pack;
1844       sobj->ty   = ty;
1845       sobj->size = size;
1846     } else {
1847       PyObject_DEL((PyObject *) sobj);
1848       sobj = 0;
1849     }
1850   }
1851   return (PyObject *) sobj;
1852 }
1853 
1854 SWIGRUNTIME swig_type_info *
1855 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1856 {
1857   if (PySwigPacked_Check(obj)) {
1858     PySwigPacked *sobj = (PySwigPacked *)obj;
1859     if (sobj->size != size) return 0;
1860     memcpy(ptr, sobj->pack, size);
1861     return sobj->ty;
1862   } else {
1863     return 0;
1864   }
1865 }
1866 
1867 /* -----------------------------------------------------------------------------
1868  * pointers/data manipulation
1869  * ----------------------------------------------------------------------------- */
1870 
1871 SWIGRUNTIMEINLINE PyObject *
1872 _SWIG_This(void)
1873 {
1874   return PyString_FromString("this");
1875 }
1876 
1877 SWIGRUNTIME PyObject *
1878 SWIG_This(void)
1879 {
1880   static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1881   return swig_this;
1882 }
1883 
1884 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1885 
1886 SWIGRUNTIME PySwigObject *
1887 SWIG_Python_GetSwigThis(PyObject *pyobj)
1888 {
1889   if (PySwigObject_Check(pyobj)) {
1890     return (PySwigObject *) pyobj;
1891   } else {
1892     PyObject *obj = 0;
1893 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1894     if (PyInstance_Check(pyobj)) {
1895       obj = _PyInstance_Lookup(pyobj, SWIG_This());
1896     } else {
1897       PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1898       if (dictptr != NULL) {
1899 	PyObject *dict = *dictptr;
1900 	obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1901       } else {
1902 #ifdef PyWeakref_CheckProxy
1903 	if (PyWeakref_CheckProxy(pyobj)) {
1904 	  PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1905 	  return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1906 	}
1907 #endif
1908 	obj = PyObject_GetAttr(pyobj,SWIG_This());
1909 	if (obj) {
1910 	  Py_DECREF(obj);
1911 	} else {
1912 	  if (PyErr_Occurred()) PyErr_Clear();
1913 	  return 0;
1914 	}
1915       }
1916     }
1917 #else
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 #endif
1926     if (obj && !PySwigObject_Check(obj)) {
1927       /* a PyObject is called 'this', try to get the 'real this'
1928 	 PySwigObject from it */
1929       return SWIG_Python_GetSwigThis(obj);
1930     }
1931     return (PySwigObject *)obj;
1932   }
1933 }
1934 
1935 /* Acquire a pointer value */
1936 
1937 SWIGRUNTIME int
1938 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1939   if (own) {
1940     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1941     if (sobj) {
1942       int oldown = sobj->own;
1943       sobj->own = own;
1944       return oldown;
1945     }
1946   }
1947   return 0;
1948 }
1949 
1950 /* Convert a pointer value */
1951 
1952 SWIGRUNTIME int
1953 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1954   if (!obj) return SWIG_ERROR;
1955   if (obj == Py_None) {
1956     if (ptr) *ptr = 0;
1957     return SWIG_OK;
1958   } else {
1959     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1960     while (sobj) {
1961       void *vptr = sobj->ptr;
1962       if (ty) {
1963 	swig_type_info *to = sobj->ty;
1964 	if (to == ty) {
1965 	  /* no type cast needed */
1966 	  if (ptr) *ptr = vptr;
1967 	  break;
1968 	} else {
1969 	  swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1970 	  if (!tc) {
1971 	    sobj = (PySwigObject *)sobj->next;
1972 	  } else {
1973 	    if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1974 	    break;
1975 	  }
1976 	}
1977       } else {
1978 	if (ptr) *ptr = vptr;
1979 	break;
1980       }
1981     }
1982     if (sobj) {
1983       if (own) *own = sobj->own;
1984       if (flags & SWIG_POINTER_DISOWN) {
1985 	sobj->own = 0;
1986       }
1987       return SWIG_OK;
1988     } else {
1989       int res = SWIG_ERROR;
1990       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
1991 	PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1992 	if (data && !data->implicitconv) {
1993 	  PyObject *klass = data->klass;
1994 	  if (klass) {
1995 	    PyObject *impconv;
1996 	    data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
1997 	    impconv = SWIG_Python_CallFunctor(klass, obj);
1998 	    data->implicitconv = 0;
1999 	    if (PyErr_Occurred()) {
2000 	      PyErr_Clear();
2001 	      impconv = 0;
2002 	    }
2003 	    if (impconv) {
2004 	      PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2005 	      if (iobj) {
2006 		void *vptr;
2007 		res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2008 		if (SWIG_IsOK(res)) {
2009 		  if (ptr) {
2010 		    *ptr = vptr;
2011 		    /* transfer the ownership to 'ptr' */
2012 		    iobj->own = 0;
2013 		    res = SWIG_AddCast(res);
2014 		    res = SWIG_AddNewMask(res);
2015 		  } else {
2016 		    res = SWIG_AddCast(res);
2017 		  }
2018 		}
2019 	      }
2020 	      Py_DECREF(impconv);
2021 	    }
2022 	  }
2023 	}
2024       }
2025       return res;
2026     }
2027   }
2028 }
2029 
2030 /* Convert a function ptr value */
2031 
2032 SWIGRUNTIME int
2033 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2034   if (!PyCFunction_Check(obj)) {
2035     return SWIG_ConvertPtr(obj, ptr, ty, 0);
2036   } else {
2037     void *vptr = 0;
2038 
2039     /* here we get the method pointer for callbacks */
2040     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2041     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2042     if (desc) {
2043       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2044       if (!desc) return SWIG_ERROR;
2045     }
2046     if (ty) {
2047       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2048       if (!tc) return SWIG_ERROR;
2049       *ptr = SWIG_TypeCast(tc,vptr);
2050     } else {
2051       *ptr = vptr;
2052     }
2053     return SWIG_OK;
2054   }
2055 }
2056 
2057 /* Convert a packed value value */
2058 
2059 SWIGRUNTIME int
2060 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2061   swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2062   if (!to) return SWIG_ERROR;
2063   if (ty) {
2064     if (to != ty) {
2065       /* check type cast? */
2066       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2067       if (!tc) return SWIG_ERROR;
2068     }
2069   }
2070   return SWIG_OK;
2071 }
2072 
2073 /* -----------------------------------------------------------------------------
2074  * Create a new pointer object
2075  * ----------------------------------------------------------------------------- */
2076 
2077 /*
2078   Create a new instance object, whitout calling __init__, and set the
2079   'this' attribute.
2080 */
2081 
2082 SWIGRUNTIME PyObject*
2083 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2084 {
2085 #if (PY_VERSION_HEX >= 0x02020000)
2086   PyObject *inst = 0;
2087   PyObject *newraw = data->newraw;
2088   if (newraw) {
2089     inst = PyObject_Call(newraw, data->newargs, NULL);
2090     if (inst) {
2091 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2092       PyObject **dictptr = _PyObject_GetDictPtr(inst);
2093       if (dictptr != NULL) {
2094 	PyObject *dict = *dictptr;
2095 	if (dict == NULL) {
2096 	  dict = PyDict_New();
2097 	  *dictptr = dict;
2098 	  PyDict_SetItem(dict, SWIG_This(), swig_this);
2099 	}
2100       }
2101 #else
2102       PyObject *key = SWIG_This();
2103       PyObject_SetAttr(inst, key, swig_this);
2104 #endif
2105     }
2106   } else {
2107     PyObject *dict = PyDict_New();
2108     PyDict_SetItem(dict, SWIG_This(), swig_this);
2109     inst = PyInstance_NewRaw(data->newargs, dict);
2110     Py_DECREF(dict);
2111   }
2112   return inst;
2113 #else
2114 #if (PY_VERSION_HEX >= 0x02010000)
2115   PyObject *inst;
2116   PyObject *dict = PyDict_New();
2117   PyDict_SetItem(dict, SWIG_This(), swig_this);
2118   inst = PyInstance_NewRaw(data->newargs, dict);
2119   Py_DECREF(dict);
2120   return (PyObject *) inst;
2121 #else
2122   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2123   if (inst == NULL) {
2124     return NULL;
2125   }
2126   inst->in_class = (PyClassObject *)data->newargs;
2127   Py_INCREF(inst->in_class);
2128   inst->in_dict = PyDict_New();
2129   if (inst->in_dict == NULL) {
2130     Py_DECREF(inst);
2131     return NULL;
2132   }
2133 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2134   inst->in_weakreflist = NULL;
2135 #endif
2136 #ifdef Py_TPFLAGS_GC
2137   PyObject_GC_Init(inst);
2138 #endif
2139   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2140   return (PyObject *) inst;
2141 #endif
2142 #endif
2143 }
2144 
2145 SWIGRUNTIME void
2146 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2147 {
2148  PyObject *dict;
2149 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2150  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2151  if (dictptr != NULL) {
2152    dict = *dictptr;
2153    if (dict == NULL) {
2154      dict = PyDict_New();
2155      *dictptr = dict;
2156    }
2157    PyDict_SetItem(dict, SWIG_This(), swig_this);
2158    return;
2159  }
2160 #endif
2161  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2162  PyDict_SetItem(dict, SWIG_This(), swig_this);
2163  Py_DECREF(dict);
2164 }
2165 
2166 
2167 SWIGINTERN PyObject *
2168 SWIG_Python_InitShadowInstance(PyObject *args) {
2169   PyObject *obj[2];
2170   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2171     return NULL;
2172   } else {
2173     PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2174     if (sthis) {
2175       PySwigObject_append((PyObject*) sthis, obj[1]);
2176     } else {
2177       SWIG_Python_SetSwigThis(obj[0], obj[1]);
2178     }
2179     return SWIG_Py_Void();
2180   }
2181 }
2182 
2183 /* Create a new pointer object */
2184 
2185 SWIGRUNTIME PyObject *
2186 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2187   if (!ptr) {
2188     return SWIG_Py_Void();
2189   } else {
2190     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2191     PyObject *robj = PySwigObject_New(ptr, type, own);
2192     PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2193     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2194       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2195       if (inst) {
2196 	Py_DECREF(robj);
2197 	robj = inst;
2198       }
2199     }
2200     return robj;
2201   }
2202 }
2203 
2204 /* Create a new packed object */
2205 
2206 SWIGRUNTIMEINLINE PyObject *
2207 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2208   return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2209 }
2210 
2211 /* -----------------------------------------------------------------------------*
2212  *  Get type list
2213  * -----------------------------------------------------------------------------*/
2214 
2215 #ifdef SWIG_LINK_RUNTIME
2216 void *SWIG_ReturnGlobalTypeList(void *);
2217 #endif
2218 
2219 SWIGRUNTIME swig_module_info *
2220 SWIG_Python_GetModule(void) {
2221   static void *type_pointer = (void *)0;
2222   /* first check if module already created */
2223   if (!type_pointer) {
2224 #ifdef SWIG_LINK_RUNTIME
2225     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2226 #else
2227     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2228 				    (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2229     if (PyErr_Occurred()) {
2230       PyErr_Clear();
2231       type_pointer = (void *)0;
2232     }
2233 #endif
2234   }
2235   return (swig_module_info *) type_pointer;
2236 }
2237 
2238 #if PY_MAJOR_VERSION < 2
2239 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
2240    is copied out of Python/modsupport.c in python version 2.3.4 */
2241 SWIGINTERN int
2242 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2243 {
2244   PyObject *dict;
2245   if (!PyModule_Check(m)) {
2246     PyErr_SetString(PyExc_TypeError,
2247 		    "PyModule_AddObject() needs module as first arg");
2248     return SWIG_ERROR;
2249   }
2250   if (!o) {
2251     PyErr_SetString(PyExc_TypeError,
2252 		    "PyModule_AddObject() needs non-NULL value");
2253     return SWIG_ERROR;
2254   }
2255 
2256   dict = PyModule_GetDict(m);
2257   if (dict == NULL) {
2258     /* Internal error -- modules must have a dict! */
2259     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2260 		 PyModule_GetName(m));
2261     return SWIG_ERROR;
2262   }
2263   if (PyDict_SetItemString(dict, name, o))
2264     return SWIG_ERROR;
2265   Py_DECREF(o);
2266   return SWIG_OK;
2267 }
2268 #endif
2269 
2270 SWIGRUNTIME void
2271 SWIG_Python_DestroyModule(void *vptr)
2272 {
2273   swig_module_info *swig_module = (swig_module_info *) vptr;
2274   swig_type_info **types = swig_module->types;
2275   size_t i;
2276   for (i =0; i < swig_module->size; ++i) {
2277     swig_type_info *ty = types[i];
2278     if (ty->owndata) {
2279       PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2280       if (data) PySwigClientData_Del(data);
2281     }
2282   }
2283   Py_DECREF(SWIG_This());
2284 }
2285 
2286 SWIGRUNTIME void
2287 SWIG_Python_SetModule(swig_module_info *swig_module) {
2288   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2289 
2290   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2291 				   swig_empty_runtime_method_table);
2292   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2293   if (pointer && module) {
2294     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2295   } else {
2296     Py_XDECREF(pointer);
2297   }
2298 }
2299 
2300 /* The python cached type query */
2301 SWIGRUNTIME PyObject *
2302 SWIG_Python_TypeCache(void) {
2303   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2304   return cache;
2305 }
2306 
2307 SWIGRUNTIME swig_type_info *
2308 SWIG_Python_TypeQuery(const char *type)
2309 {
2310   PyObject *cache = SWIG_Python_TypeCache();
2311   PyObject *key = PyString_FromString(type);
2312   PyObject *obj = PyDict_GetItem(cache, key);
2313   swig_type_info *descriptor;
2314   if (obj) {
2315     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2316   } else {
2317     swig_module_info *swig_module = SWIG_Python_GetModule();
2318     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2319     if (descriptor) {
2320       obj = PyCObject_FromVoidPtr(descriptor, NULL);
2321       PyDict_SetItem(cache, key, obj);
2322       Py_DECREF(obj);
2323     }
2324   }
2325   Py_DECREF(key);
2326   return descriptor;
2327 }
2328 
2329 /*
2330    For backward compatibility only
2331 */
2332 #define SWIG_POINTER_EXCEPTION  0
2333 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2334 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2335 
2336 SWIGRUNTIME int
2337 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2338 {
2339   if (PyErr_Occurred()) {
2340     PyObject *type = 0;
2341     PyObject *value = 0;
2342     PyObject *traceback = 0;
2343     PyErr_Fetch(&type, &value, &traceback);
2344     if (value) {
2345       PyObject *old_str = PyObject_Str(value);
2346       Py_XINCREF(type);
2347       PyErr_Clear();
2348       if (infront) {
2349 	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2350       } else {
2351 	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2352       }
2353       Py_DECREF(old_str);
2354     }
2355     return 1;
2356   } else {
2357     return 0;
2358   }
2359 }
2360 
2361 SWIGRUNTIME int
2362 SWIG_Python_ArgFail(int argnum)
2363 {
2364   if (PyErr_Occurred()) {
2365     /* add information about failing argument */
2366     char mesg[256];
2367     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2368     return SWIG_Python_AddErrMesg(mesg, 1);
2369   } else {
2370     return 0;
2371   }
2372 }
2373 
2374 SWIGRUNTIMEINLINE const char *
2375 PySwigObject_GetDesc(PyObject *self)
2376 {
2377   PySwigObject *v = (PySwigObject *)self;
2378   swig_type_info *ty = v ? v->ty : 0;
2379   return ty ? ty->str : (char*)"";
2380 }
2381 
2382 SWIGRUNTIME void
2383 SWIG_Python_TypeError(const char *type, PyObject *obj)
2384 {
2385   if (type) {
2386 #if defined(SWIG_COBJECT_TYPES)
2387     if (obj && PySwigObject_Check(obj)) {
2388       const char *otype = (const char *) PySwigObject_GetDesc(obj);
2389       if (otype) {
2390 	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2391 		     type, otype);
2392 	return;
2393       }
2394     } else
2395 #endif
2396     {
2397       const char *otype = (obj ? obj->ob_type->tp_name : 0);
2398       if (otype) {
2399 	PyObject *str = PyObject_Str(obj);
2400 	const char *cstr = str ? PyString_AsString(str) : 0;
2401 	if (cstr) {
2402 	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2403 		       type, otype, cstr);
2404 	} else {
2405 	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2406 		       type, otype);
2407 	}
2408 	Py_XDECREF(str);
2409 	return;
2410       }
2411     }
2412     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2413   } else {
2414     PyErr_Format(PyExc_TypeError, "unexpected type is received");
2415   }
2416 }
2417 
2418 
2419 /* Convert a pointer value, signal an exception on a type mismatch */
2420 SWIGRUNTIME void *
2421 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2422   void *result;
2423   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2424     PyErr_Clear();
2425     if (flags & SWIG_POINTER_EXCEPTION) {
2426       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2427       SWIG_Python_ArgFail(argnum);
2428     }
2429   }
2430   return result;
2431 }
2432 
2433 
2434 #ifdef __cplusplus
2435 #if 0
2436 { /* cc-mode */
2437 #endif
2438 }
2439 #endif
2440 
2441 
2442 
2443 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2444 
2445 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2446 
2447 
2448 
2449 /* -------- TYPES TABLE (BEGIN) -------- */
2450 
2451 #define SWIGTYPE_p_char swig_types[0]
2452 #define SWIGTYPE_p_netpgp_t swig_types[1]
2453 #define SWIGTYPE_p_p_char swig_types[2]
2454 #define SWIGTYPE_p_void swig_types[3]
2455 static swig_type_info *swig_types[5];
2456 static swig_module_info swig_module = {swig_types, 4, 0, 0, 0, 0};
2457 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2458 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2459 
2460 /* -------- TYPES TABLE (END) -------- */
2461 
2462 #if (PY_VERSION_HEX <= 0x02000000)
2463 # if !defined(SWIG_PYTHON_CLASSIC)
2464 #  error "This python version requires swig to be run with the '-classic' option"
2465 # endif
2466 #endif
2467 
2468 /*-----------------------------------------------
2469               @(target):= _netpgppython.so
2470   ------------------------------------------------*/
2471 #define SWIG_init    init_netpgppython
2472 
2473 #define SWIG_name    "_netpgppython"
2474 
2475 #define SWIGVERSION 0x010331
2476 #define SWIG_VERSION SWIGVERSION
2477 
2478 
2479 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
2480 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
2481 
2482 
2483 #include <netpgp.h>
2484 
2485 
2486 
2487 
2488 #include <limits.h>
2489 #ifndef LLONG_MIN
2490 # define LLONG_MIN	LONG_LONG_MIN
2491 #endif
2492 #ifndef LLONG_MAX
2493 # define LLONG_MAX	LONG_LONG_MAX
2494 #endif
2495 #ifndef ULLONG_MAX
2496 # define ULLONG_MAX	ULONG_LONG_MAX
2497 #endif
2498 
2499 
2500 SWIGINTERN int
2501 SWIG_AsVal_double (PyObject *obj, double *val)
2502 {
2503   int res = SWIG_TypeError;
2504   if (PyFloat_Check(obj)) {
2505     if (val) *val = PyFloat_AsDouble(obj);
2506     return SWIG_OK;
2507   } else if (PyInt_Check(obj)) {
2508     if (val) *val = PyInt_AsLong(obj);
2509     return SWIG_OK;
2510   } else if (PyLong_Check(obj)) {
2511     double v = PyLong_AsDouble(obj);
2512     if (!PyErr_Occurred()) {
2513       if (val) *val = v;
2514       return SWIG_OK;
2515     } else {
2516       PyErr_Clear();
2517     }
2518   }
2519 #ifdef SWIG_PYTHON_CAST_MODE
2520   {
2521     int dispatch = 0;
2522     double d = PyFloat_AsDouble(obj);
2523     if (!PyErr_Occurred()) {
2524       if (val) *val = d;
2525       return SWIG_AddCast(SWIG_OK);
2526     } else {
2527       PyErr_Clear();
2528     }
2529     if (!dispatch) {
2530       long v = PyLong_AsLong(obj);
2531       if (!PyErr_Occurred()) {
2532 	if (val) *val = v;
2533 	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2534       } else {
2535 	PyErr_Clear();
2536       }
2537     }
2538   }
2539 #endif
2540   return res;
2541 }
2542 
2543 
2544 #include <float.h>
2545 
2546 
2547 #include <math.h>
2548 
2549 
2550 SWIGINTERNINLINE int
2551 SWIG_CanCastAsInteger(double *d, double min, double max) {
2552   double x = *d;
2553   if ((min <= x && x <= max)) {
2554    double fx = floor(x);
2555    double cx = ceil(x);
2556    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2557    if ((errno == EDOM) || (errno == ERANGE)) {
2558      errno = 0;
2559    } else {
2560      double summ, reps, diff;
2561      if (rd < x) {
2562        diff = x - rd;
2563      } else if (rd > x) {
2564        diff = rd - x;
2565      } else {
2566        return 1;
2567      }
2568      summ = rd + x;
2569      reps = diff/summ;
2570      if (reps < 8*DBL_EPSILON) {
2571        *d = rd;
2572        return 1;
2573      }
2574    }
2575   }
2576   return 0;
2577 }
2578 
2579 
2580 SWIGINTERN int
2581 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
2582 {
2583   if (PyInt_Check(obj)) {
2584     long v = PyInt_AsLong(obj);
2585     if (v >= 0) {
2586       if (val) *val = v;
2587       return SWIG_OK;
2588     } else {
2589       return SWIG_OverflowError;
2590     }
2591   } else if (PyLong_Check(obj)) {
2592     unsigned long v = PyLong_AsUnsignedLong(obj);
2593     if (!PyErr_Occurred()) {
2594       if (val) *val = v;
2595       return SWIG_OK;
2596     } else {
2597       PyErr_Clear();
2598     }
2599   }
2600 #ifdef SWIG_PYTHON_CAST_MODE
2601   {
2602     int dispatch = 0;
2603     unsigned long v = PyLong_AsUnsignedLong(obj);
2604     if (!PyErr_Occurred()) {
2605       if (val) *val = v;
2606       return SWIG_AddCast(SWIG_OK);
2607     } else {
2608       PyErr_Clear();
2609     }
2610     if (!dispatch) {
2611       double d;
2612       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2613       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2614 	if (val) *val = (unsigned long)(d);
2615 	return res;
2616       }
2617     }
2618   }
2619 #endif
2620   return SWIG_TypeError;
2621 }
2622 
2623 
2624 SWIGINTERN int
2625 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
2626 {
2627   unsigned long v;
2628   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2629   if (SWIG_IsOK(res)) {
2630     if ((v > UINT_MAX)) {
2631       return SWIG_OverflowError;
2632     } else {
2633       if (val) *val = (unsigned int)(v);
2634     }
2635   }
2636   return res;
2637 }
2638 
2639 
2640   #define SWIG_From_long   PyInt_FromLong
2641 
2642 
2643 SWIGINTERNINLINE PyObject*
2644 SWIG_From_unsigned_SS_long  (unsigned long value)
2645 {
2646   return (value > LONG_MAX) ?
2647     PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
2648 }
2649 
2650 
2651 SWIGINTERNINLINE PyObject *
2652 SWIG_From_unsigned_SS_int  (unsigned int value)
2653 {
2654   return SWIG_From_unsigned_SS_long  (value);
2655 }
2656 
2657 
2658 SWIGINTERNINLINE PyObject *
2659 SWIG_From_int  (int value)
2660 {
2661   return SWIG_From_long  (value);
2662 }
2663 
2664 
2665 SWIGINTERN swig_type_info*
2666 SWIG_pchar_descriptor(void)
2667 {
2668   static int init = 0;
2669   static swig_type_info* info = 0;
2670   if (!init) {
2671     info = SWIG_TypeQuery("_p_char");
2672     init = 1;
2673   }
2674   return info;
2675 }
2676 
2677 
2678 SWIGINTERN int
2679 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
2680 {
2681   if (PyString_Check(obj)) {
2682     char *cstr; Py_ssize_t len;
2683     PyString_AsStringAndSize(obj, &cstr, &len);
2684     if (cptr)  {
2685       if (alloc) {
2686 	/*
2687 	   In python the user should not be able to modify the inner
2688 	   string representation. To warranty that, if you define
2689 	   SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
2690 	   buffer is always returned.
2691 
2692 	   The default behavior is just to return the pointer value,
2693 	   so, be careful.
2694 	*/
2695 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
2696 	if (*alloc != SWIG_OLDOBJ)
2697 #else
2698 	if (*alloc == SWIG_NEWOBJ)
2699 #endif
2700 	  {
2701 	    *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
2702 	    *alloc = SWIG_NEWOBJ;
2703 	  }
2704 	else {
2705 	  *cptr = cstr;
2706 	  *alloc = SWIG_OLDOBJ;
2707 	}
2708       } else {
2709 	*cptr = PyString_AsString(obj);
2710       }
2711     }
2712     if (psize) *psize = len + 1;
2713     return SWIG_OK;
2714   } else {
2715     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2716     if (pchar_descriptor) {
2717       void* vptr = 0;
2718       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
2719 	if (cptr) *cptr = (char *) vptr;
2720 	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
2721 	if (alloc) *alloc = SWIG_OLDOBJ;
2722 	return SWIG_OK;
2723       }
2724     }
2725   }
2726   return SWIG_TypeError;
2727 }
2728 
2729 
2730 
2731 
2732 
2733 SWIGINTERNINLINE PyObject *
2734 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2735 {
2736   if (carray) {
2737     if (size > INT_MAX) {
2738       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2739       return pchar_descriptor ?
2740 	SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2741     } else {
2742       return PyString_FromStringAndSize(carray, (int)(size));
2743     }
2744   } else {
2745     return SWIG_Py_Void();
2746   }
2747 }
2748 
2749 
2750 SWIGINTERNINLINE PyObject *
2751 SWIG_FromCharPtr(const char *cptr)
2752 {
2753   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2754 }
2755 
2756 
2757 SWIGINTERN int
2758 SWIG_AsVal_long (PyObject *obj, long* val)
2759 {
2760   if (PyInt_Check(obj)) {
2761     if (val) *val = PyInt_AsLong(obj);
2762     return SWIG_OK;
2763   } else if (PyLong_Check(obj)) {
2764     long v = PyLong_AsLong(obj);
2765     if (!PyErr_Occurred()) {
2766       if (val) *val = v;
2767       return SWIG_OK;
2768     } else {
2769       PyErr_Clear();
2770     }
2771   }
2772 #ifdef SWIG_PYTHON_CAST_MODE
2773   {
2774     int dispatch = 0;
2775     long v = PyInt_AsLong(obj);
2776     if (!PyErr_Occurred()) {
2777       if (val) *val = v;
2778       return SWIG_AddCast(SWIG_OK);
2779     } else {
2780       PyErr_Clear();
2781     }
2782     if (!dispatch) {
2783       double d;
2784       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2785       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2786 	if (val) *val = (long)(d);
2787 	return res;
2788       }
2789     }
2790   }
2791 #endif
2792   return SWIG_TypeError;
2793 }
2794 
2795 
2796 SWIGINTERN int
2797 SWIG_AsVal_int (PyObject * obj, int *val)
2798 {
2799   long v;
2800   int res = SWIG_AsVal_long (obj, &v);
2801   if (SWIG_IsOK(res)) {
2802     if ((v < INT_MIN || v > INT_MAX)) {
2803       return SWIG_OverflowError;
2804     } else {
2805       if (val) *val = (int)(v);
2806     }
2807   }
2808   return res;
2809 }
2810 
2811 
2812 SWIGINTERNINLINE int
2813 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2814 {
2815   unsigned long v;
2816   int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2817   if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2818   return res;
2819 }
2820 
2821 #ifdef __cplusplus
2822 extern "C" {
2823 #endif
2824 SWIGINTERN PyObject *_wrap_netpgp_t_c_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2825   PyObject *resultobj = 0;
2826   netpgp_t *arg1 = (netpgp_t *) 0 ;
2827   unsigned int arg2 ;
2828   void *argp1 = 0 ;
2829   int res1 = 0 ;
2830   unsigned int val2 ;
2831   int ecode2 = 0 ;
2832   PyObject * obj0 = 0 ;
2833   PyObject * obj1 = 0 ;
2834 
2835   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_t_c_set",&obj0,&obj1)) SWIG_fail;
2836   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2837   if (!SWIG_IsOK(res1)) {
2838     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_c_set" "', argument " "1"" of type '" "netpgp_t *""'");
2839   }
2840   arg1 = (netpgp_t *)(argp1);
2841   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
2842   if (!SWIG_IsOK(ecode2)) {
2843     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "netpgp_t_c_set" "', argument " "2"" of type '" "unsigned int""'");
2844   }
2845   arg2 = (unsigned int)(val2);
2846   if (arg1) (arg1)->c = arg2;
2847 
2848   resultobj = SWIG_Py_Void();
2849   return resultobj;
2850 fail:
2851   return NULL;
2852 }
2853 
2854 
2855 SWIGINTERN PyObject *_wrap_netpgp_t_c_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2856   PyObject *resultobj = 0;
2857   netpgp_t *arg1 = (netpgp_t *) 0 ;
2858   unsigned int result;
2859   void *argp1 = 0 ;
2860   int res1 = 0 ;
2861   PyObject * obj0 = 0 ;
2862 
2863   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_t_c_get",&obj0)) SWIG_fail;
2864   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2865   if (!SWIG_IsOK(res1)) {
2866     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_c_get" "', argument " "1"" of type '" "netpgp_t *""'");
2867   }
2868   arg1 = (netpgp_t *)(argp1);
2869   result = (unsigned int) ((arg1)->c);
2870   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
2871   return resultobj;
2872 fail:
2873   return NULL;
2874 }
2875 
2876 
2877 SWIGINTERN PyObject *_wrap_netpgp_t_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2878   PyObject *resultobj = 0;
2879   netpgp_t *arg1 = (netpgp_t *) 0 ;
2880   unsigned int arg2 ;
2881   void *argp1 = 0 ;
2882   int res1 = 0 ;
2883   unsigned int val2 ;
2884   int ecode2 = 0 ;
2885   PyObject * obj0 = 0 ;
2886   PyObject * obj1 = 0 ;
2887 
2888   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_t_size_set",&obj0,&obj1)) SWIG_fail;
2889   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2890   if (!SWIG_IsOK(res1)) {
2891     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_size_set" "', argument " "1"" of type '" "netpgp_t *""'");
2892   }
2893   arg1 = (netpgp_t *)(argp1);
2894   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
2895   if (!SWIG_IsOK(ecode2)) {
2896     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "netpgp_t_size_set" "', argument " "2"" of type '" "unsigned int""'");
2897   }
2898   arg2 = (unsigned int)(val2);
2899   if (arg1) (arg1)->size = arg2;
2900 
2901   resultobj = SWIG_Py_Void();
2902   return resultobj;
2903 fail:
2904   return NULL;
2905 }
2906 
2907 
2908 SWIGINTERN PyObject *_wrap_netpgp_t_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2909   PyObject *resultobj = 0;
2910   netpgp_t *arg1 = (netpgp_t *) 0 ;
2911   unsigned int result;
2912   void *argp1 = 0 ;
2913   int res1 = 0 ;
2914   PyObject * obj0 = 0 ;
2915 
2916   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_t_size_get",&obj0)) SWIG_fail;
2917   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2918   if (!SWIG_IsOK(res1)) {
2919     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_size_get" "', argument " "1"" of type '" "netpgp_t *""'");
2920   }
2921   arg1 = (netpgp_t *)(argp1);
2922   result = (unsigned int) ((arg1)->size);
2923   resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
2924   return resultobj;
2925 fail:
2926   return NULL;
2927 }
2928 
2929 
2930 SWIGINTERN PyObject *_wrap_netpgp_t_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2931   PyObject *resultobj = 0;
2932   netpgp_t *arg1 = (netpgp_t *) 0 ;
2933   char **arg2 = (char **) 0 ;
2934   void *argp1 = 0 ;
2935   int res1 = 0 ;
2936   void *argp2 = 0 ;
2937   int res2 = 0 ;
2938   PyObject * obj0 = 0 ;
2939   PyObject * obj1 = 0 ;
2940 
2941   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_t_name_set",&obj0,&obj1)) SWIG_fail;
2942   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2943   if (!SWIG_IsOK(res1)) {
2944     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_name_set" "', argument " "1"" of type '" "netpgp_t *""'");
2945   }
2946   arg1 = (netpgp_t *)(argp1);
2947   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
2948   if (!SWIG_IsOK(res2)) {
2949     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_name_set" "', argument " "2"" of type '" "char **""'");
2950   }
2951   arg2 = (char **)(argp2);
2952   if (arg1) (arg1)->name = arg2;
2953 
2954   resultobj = SWIG_Py_Void();
2955   return resultobj;
2956 fail:
2957   return NULL;
2958 }
2959 
2960 
2961 SWIGINTERN PyObject *_wrap_netpgp_t_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2962   PyObject *resultobj = 0;
2963   netpgp_t *arg1 = (netpgp_t *) 0 ;
2964   char **result = 0 ;
2965   void *argp1 = 0 ;
2966   int res1 = 0 ;
2967   PyObject * obj0 = 0 ;
2968 
2969   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_t_name_get",&obj0)) SWIG_fail;
2970   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2971   if (!SWIG_IsOK(res1)) {
2972     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_name_get" "', argument " "1"" of type '" "netpgp_t *""'");
2973   }
2974   arg1 = (netpgp_t *)(argp1);
2975   result = (char **) ((arg1)->name);
2976   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
2977   return resultobj;
2978 fail:
2979   return NULL;
2980 }
2981 
2982 
2983 SWIGINTERN PyObject *_wrap_netpgp_t_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
2984   PyObject *resultobj = 0;
2985   netpgp_t *arg1 = (netpgp_t *) 0 ;
2986   char **arg2 = (char **) 0 ;
2987   void *argp1 = 0 ;
2988   int res1 = 0 ;
2989   void *argp2 = 0 ;
2990   int res2 = 0 ;
2991   PyObject * obj0 = 0 ;
2992   PyObject * obj1 = 0 ;
2993 
2994   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_t_value_set",&obj0,&obj1)) SWIG_fail;
2995   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2996   if (!SWIG_IsOK(res1)) {
2997     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_value_set" "', argument " "1"" of type '" "netpgp_t *""'");
2998   }
2999   arg1 = (netpgp_t *)(argp1);
3000   res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 |  0 );
3001   if (!SWIG_IsOK(res2)) {
3002     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_value_set" "', argument " "2"" of type '" "char **""'");
3003   }
3004   arg2 = (char **)(argp2);
3005   if (arg1) (arg1)->value = arg2;
3006 
3007   resultobj = SWIG_Py_Void();
3008   return resultobj;
3009 fail:
3010   return NULL;
3011 }
3012 
3013 
3014 SWIGINTERN PyObject *_wrap_netpgp_t_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3015   PyObject *resultobj = 0;
3016   netpgp_t *arg1 = (netpgp_t *) 0 ;
3017   char **result = 0 ;
3018   void *argp1 = 0 ;
3019   int res1 = 0 ;
3020   PyObject * obj0 = 0 ;
3021 
3022   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_t_value_get",&obj0)) SWIG_fail;
3023   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3024   if (!SWIG_IsOK(res1)) {
3025     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_value_get" "', argument " "1"" of type '" "netpgp_t *""'");
3026   }
3027   arg1 = (netpgp_t *)(argp1);
3028   result = (char **) ((arg1)->value);
3029   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 |  0 );
3030   return resultobj;
3031 fail:
3032   return NULL;
3033 }
3034 
3035 
3036 SWIGINTERN PyObject *_wrap_netpgp_t_pubring_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3037   PyObject *resultobj = 0;
3038   netpgp_t *arg1 = (netpgp_t *) 0 ;
3039   void *arg2 = (void *) 0 ;
3040   void *argp1 = 0 ;
3041   int res1 = 0 ;
3042   int res2 ;
3043   PyObject * obj0 = 0 ;
3044   PyObject * obj1 = 0 ;
3045 
3046   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_t_pubring_set",&obj0,&obj1)) SWIG_fail;
3047   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3048   if (!SWIG_IsOK(res1)) {
3049     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_pubring_set" "', argument " "1"" of type '" "netpgp_t *""'");
3050   }
3051   arg1 = (netpgp_t *)(argp1);
3052   res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
3053   if (!SWIG_IsOK(res2)) {
3054     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_pubring_set" "', argument " "2"" of type '" "void *""'");
3055   }
3056   if (arg1) (arg1)->pubring = arg2;
3057 
3058   resultobj = SWIG_Py_Void();
3059   return resultobj;
3060 fail:
3061   return NULL;
3062 }
3063 
3064 
3065 SWIGINTERN PyObject *_wrap_netpgp_t_pubring_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3066   PyObject *resultobj = 0;
3067   netpgp_t *arg1 = (netpgp_t *) 0 ;
3068   void *result = 0 ;
3069   void *argp1 = 0 ;
3070   int res1 = 0 ;
3071   PyObject * obj0 = 0 ;
3072 
3073   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_t_pubring_get",&obj0)) SWIG_fail;
3074   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3075   if (!SWIG_IsOK(res1)) {
3076     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_pubring_get" "', argument " "1"" of type '" "netpgp_t *""'");
3077   }
3078   arg1 = (netpgp_t *)(argp1);
3079   result = (void *) ((arg1)->pubring);
3080   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
3081   return resultobj;
3082 fail:
3083   return NULL;
3084 }
3085 
3086 
3087 SWIGINTERN PyObject *_wrap_netpgp_t_secring_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3088   PyObject *resultobj = 0;
3089   netpgp_t *arg1 = (netpgp_t *) 0 ;
3090   void *arg2 = (void *) 0 ;
3091   void *argp1 = 0 ;
3092   int res1 = 0 ;
3093   int res2 ;
3094   PyObject * obj0 = 0 ;
3095   PyObject * obj1 = 0 ;
3096 
3097   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_t_secring_set",&obj0,&obj1)) SWIG_fail;
3098   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3099   if (!SWIG_IsOK(res1)) {
3100     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_secring_set" "', argument " "1"" of type '" "netpgp_t *""'");
3101   }
3102   arg1 = (netpgp_t *)(argp1);
3103   res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
3104   if (!SWIG_IsOK(res2)) {
3105     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_secring_set" "', argument " "2"" of type '" "void *""'");
3106   }
3107   if (arg1) (arg1)->secring = arg2;
3108 
3109   resultobj = SWIG_Py_Void();
3110   return resultobj;
3111 fail:
3112   return NULL;
3113 }
3114 
3115 
3116 SWIGINTERN PyObject *_wrap_netpgp_t_secring_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3117   PyObject *resultobj = 0;
3118   netpgp_t *arg1 = (netpgp_t *) 0 ;
3119   void *result = 0 ;
3120   void *argp1 = 0 ;
3121   int res1 = 0 ;
3122   PyObject * obj0 = 0 ;
3123 
3124   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_t_secring_get",&obj0)) SWIG_fail;
3125   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3126   if (!SWIG_IsOK(res1)) {
3127     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_secring_get" "', argument " "1"" of type '" "netpgp_t *""'");
3128   }
3129   arg1 = (netpgp_t *)(argp1);
3130   result = (void *) ((arg1)->secring);
3131   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
3132   return resultobj;
3133 fail:
3134   return NULL;
3135 }
3136 
3137 
3138 SWIGINTERN PyObject *_wrap_netpgp_t_io_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3139   PyObject *resultobj = 0;
3140   netpgp_t *arg1 = (netpgp_t *) 0 ;
3141   void *arg2 = (void *) 0 ;
3142   void *argp1 = 0 ;
3143   int res1 = 0 ;
3144   int res2 ;
3145   PyObject * obj0 = 0 ;
3146   PyObject * obj1 = 0 ;
3147 
3148   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_t_io_set",&obj0,&obj1)) SWIG_fail;
3149   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3150   if (!SWIG_IsOK(res1)) {
3151     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_io_set" "', argument " "1"" of type '" "netpgp_t *""'");
3152   }
3153   arg1 = (netpgp_t *)(argp1);
3154   res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
3155   if (!SWIG_IsOK(res2)) {
3156     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_io_set" "', argument " "2"" of type '" "void *""'");
3157   }
3158   if (arg1) (arg1)->io = arg2;
3159 
3160   resultobj = SWIG_Py_Void();
3161   return resultobj;
3162 fail:
3163   return NULL;
3164 }
3165 
3166 
3167 SWIGINTERN PyObject *_wrap_netpgp_t_io_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3168   PyObject *resultobj = 0;
3169   netpgp_t *arg1 = (netpgp_t *) 0 ;
3170   void *result = 0 ;
3171   void *argp1 = 0 ;
3172   int res1 = 0 ;
3173   PyObject * obj0 = 0 ;
3174 
3175   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_t_io_get",&obj0)) SWIG_fail;
3176   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3177   if (!SWIG_IsOK(res1)) {
3178     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_io_get" "', argument " "1"" of type '" "netpgp_t *""'");
3179   }
3180   arg1 = (netpgp_t *)(argp1);
3181   result = (void *) ((arg1)->io);
3182   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
3183   return resultobj;
3184 fail:
3185   return NULL;
3186 }
3187 
3188 
3189 SWIGINTERN PyObject *_wrap_netpgp_t_passfp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3190   PyObject *resultobj = 0;
3191   netpgp_t *arg1 = (netpgp_t *) 0 ;
3192   void *arg2 = (void *) 0 ;
3193   void *argp1 = 0 ;
3194   int res1 = 0 ;
3195   int res2 ;
3196   PyObject * obj0 = 0 ;
3197   PyObject * obj1 = 0 ;
3198 
3199   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_t_passfp_set",&obj0,&obj1)) SWIG_fail;
3200   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3201   if (!SWIG_IsOK(res1)) {
3202     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_passfp_set" "', argument " "1"" of type '" "netpgp_t *""'");
3203   }
3204   arg1 = (netpgp_t *)(argp1);
3205   res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
3206   if (!SWIG_IsOK(res2)) {
3207     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_passfp_set" "', argument " "2"" of type '" "void *""'");
3208   }
3209   if (arg1) (arg1)->passfp = arg2;
3210 
3211   resultobj = SWIG_Py_Void();
3212   return resultobj;
3213 fail:
3214   return NULL;
3215 }
3216 
3217 
3218 SWIGINTERN PyObject *_wrap_netpgp_t_passfp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3219   PyObject *resultobj = 0;
3220   netpgp_t *arg1 = (netpgp_t *) 0 ;
3221   void *result = 0 ;
3222   void *argp1 = 0 ;
3223   int res1 = 0 ;
3224   PyObject * obj0 = 0 ;
3225 
3226   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_t_passfp_get",&obj0)) SWIG_fail;
3227   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3228   if (!SWIG_IsOK(res1)) {
3229     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_passfp_get" "', argument " "1"" of type '" "netpgp_t *""'");
3230   }
3231   arg1 = (netpgp_t *)(argp1);
3232   result = (void *) ((arg1)->passfp);
3233   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
3234   return resultobj;
3235 fail:
3236   return NULL;
3237 }
3238 
3239 
3240 SWIGINTERN PyObject *_wrap_new_netpgp_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3241   PyObject *resultobj = 0;
3242   netpgp_t *result = 0 ;
3243 
3244   if (!PyArg_ParseTuple(args,(char *)":new_netpgp_t")) SWIG_fail;
3245   result = (netpgp_t *)(netpgp_t *) calloc(1, sizeof(netpgp_t));
3246   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_netpgp_t, SWIG_POINTER_NEW |  0 );
3247   return resultobj;
3248 fail:
3249   return NULL;
3250 }
3251 
3252 
3253 SWIGINTERN PyObject *_wrap_delete_netpgp_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3254   PyObject *resultobj = 0;
3255   netpgp_t *arg1 = (netpgp_t *) 0 ;
3256   void *argp1 = 0 ;
3257   int res1 = 0 ;
3258   PyObject * obj0 = 0 ;
3259 
3260   if (!PyArg_ParseTuple(args,(char *)"O:delete_netpgp_t",&obj0)) SWIG_fail;
3261   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, SWIG_POINTER_DISOWN |  0 );
3262   if (!SWIG_IsOK(res1)) {
3263     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_netpgp_t" "', argument " "1"" of type '" "netpgp_t *""'");
3264   }
3265   arg1 = (netpgp_t *)(argp1);
3266   free((char *) arg1);
3267 
3268   resultobj = SWIG_Py_Void();
3269   return resultobj;
3270 fail:
3271   return NULL;
3272 }
3273 
3274 
3275 SWIGINTERN PyObject *netpgp_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3276   PyObject *obj;
3277   if (!PyArg_ParseTuple(args,(char*)"O|swigregister", &obj)) return NULL;
3278   SWIG_TypeNewClientData(SWIGTYPE_p_netpgp_t, SWIG_NewClientData(obj));
3279   return SWIG_Py_Void();
3280 }
3281 
3282 SWIGINTERN PyObject *_wrap_netpgp_init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3283   PyObject *resultobj = 0;
3284   netpgp_t *arg1 = (netpgp_t *) 0 ;
3285   int result;
3286   void *argp1 = 0 ;
3287   int res1 = 0 ;
3288   PyObject * obj0 = 0 ;
3289 
3290   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_init",&obj0)) SWIG_fail;
3291   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3292   if (!SWIG_IsOK(res1)) {
3293     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_init" "', argument " "1"" of type '" "netpgp_t *""'");
3294   }
3295   arg1 = (netpgp_t *)(argp1);
3296   result = (int)netpgp_init(arg1);
3297   resultobj = SWIG_From_int((int)(result));
3298   return resultobj;
3299 fail:
3300   return NULL;
3301 }
3302 
3303 
3304 SWIGINTERN PyObject *_wrap_netpgp_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3305   PyObject *resultobj = 0;
3306   netpgp_t *arg1 = (netpgp_t *) 0 ;
3307   int result;
3308   void *argp1 = 0 ;
3309   int res1 = 0 ;
3310   PyObject * obj0 = 0 ;
3311 
3312   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_end",&obj0)) SWIG_fail;
3313   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3314   if (!SWIG_IsOK(res1)) {
3315     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_end" "', argument " "1"" of type '" "netpgp_t *""'");
3316   }
3317   arg1 = (netpgp_t *)(argp1);
3318   result = (int)netpgp_end(arg1);
3319   resultobj = SWIG_From_int((int)(result));
3320   return resultobj;
3321 fail:
3322   return NULL;
3323 }
3324 
3325 
3326 SWIGINTERN PyObject *_wrap_netpgp_set_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3327   PyObject *resultobj = 0;
3328   char *arg1 = (char *) 0 ;
3329   int result;
3330   int res1 ;
3331   char *buf1 = 0 ;
3332   int alloc1 = 0 ;
3333   PyObject * obj0 = 0 ;
3334 
3335   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_set_debug",&obj0)) SWIG_fail;
3336   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
3337   if (!SWIG_IsOK(res1)) {
3338     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_set_debug" "', argument " "1"" of type '" "char const *""'");
3339   }
3340   arg1 = (char *)(buf1);
3341   result = (int)netpgp_set_debug((char const *)arg1);
3342   resultobj = SWIG_From_int((int)(result));
3343   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3344   return resultobj;
3345 fail:
3346   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3347   return NULL;
3348 }
3349 
3350 
3351 SWIGINTERN PyObject *_wrap_netpgp_get_debug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3352   PyObject *resultobj = 0;
3353   char *arg1 = (char *) 0 ;
3354   int result;
3355   int res1 ;
3356   char *buf1 = 0 ;
3357   int alloc1 = 0 ;
3358   PyObject * obj0 = 0 ;
3359 
3360   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_get_debug",&obj0)) SWIG_fail;
3361   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
3362   if (!SWIG_IsOK(res1)) {
3363     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_get_debug" "', argument " "1"" of type '" "char const *""'");
3364   }
3365   arg1 = (char *)(buf1);
3366   result = (int)netpgp_get_debug((char const *)arg1);
3367   resultobj = SWIG_From_int((int)(result));
3368   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3369   return resultobj;
3370 fail:
3371   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3372   return NULL;
3373 }
3374 
3375 
3376 SWIGINTERN PyObject *_wrap_netpgp_get_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3377   PyObject *resultobj = 0;
3378   char *arg1 = (char *) 0 ;
3379   char *result = 0 ;
3380   int res1 ;
3381   char *buf1 = 0 ;
3382   int alloc1 = 0 ;
3383   PyObject * obj0 = 0 ;
3384 
3385   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_get_info",&obj0)) SWIG_fail;
3386   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
3387   if (!SWIG_IsOK(res1)) {
3388     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_get_info" "', argument " "1"" of type '" "char const *""'");
3389   }
3390   arg1 = (char *)(buf1);
3391   result = (char *)netpgp_get_info((char const *)arg1);
3392   resultobj = SWIG_FromCharPtr((const char *)result);
3393   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3394   return resultobj;
3395 fail:
3396   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3397   return NULL;
3398 }
3399 
3400 
3401 SWIGINTERN PyObject *_wrap_netpgp_list_packets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3402   PyObject *resultobj = 0;
3403   netpgp_t *arg1 = (netpgp_t *) 0 ;
3404   char *arg2 = (char *) 0 ;
3405   int arg3 ;
3406   char *arg4 = (char *) 0 ;
3407   int result;
3408   void *argp1 = 0 ;
3409   int res1 = 0 ;
3410   int res2 ;
3411   char *buf2 = 0 ;
3412   int alloc2 = 0 ;
3413   int val3 ;
3414   int ecode3 = 0 ;
3415   int res4 ;
3416   char *buf4 = 0 ;
3417   int alloc4 = 0 ;
3418   PyObject * obj0 = 0 ;
3419   PyObject * obj1 = 0 ;
3420   PyObject * obj2 = 0 ;
3421   PyObject * obj3 = 0 ;
3422 
3423   if (!PyArg_ParseTuple(args,(char *)"OOOO:netpgp_list_packets",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3424   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3425   if (!SWIG_IsOK(res1)) {
3426     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_list_packets" "', argument " "1"" of type '" "netpgp_t *""'");
3427   }
3428   arg1 = (netpgp_t *)(argp1);
3429   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3430   if (!SWIG_IsOK(res2)) {
3431     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_list_packets" "', argument " "2"" of type '" "char *""'");
3432   }
3433   arg2 = (char *)(buf2);
3434   ecode3 = SWIG_AsVal_int(obj2, &val3);
3435   if (!SWIG_IsOK(ecode3)) {
3436     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "netpgp_list_packets" "', argument " "3"" of type '" "int""'");
3437   }
3438   arg3 = (int)(val3);
3439   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
3440   if (!SWIG_IsOK(res4)) {
3441     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "netpgp_list_packets" "', argument " "4"" of type '" "char *""'");
3442   }
3443   arg4 = (char *)(buf4);
3444   result = (int)netpgp_list_packets(arg1,arg2,arg3,arg4);
3445   resultobj = SWIG_From_int((int)(result));
3446   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3447   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3448   return resultobj;
3449 fail:
3450   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3451   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3452   return NULL;
3453 }
3454 
3455 
3456 SWIGINTERN PyObject *_wrap_netpgp_setvar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3457   PyObject *resultobj = 0;
3458   netpgp_t *arg1 = (netpgp_t *) 0 ;
3459   char *arg2 = (char *) 0 ;
3460   char *arg3 = (char *) 0 ;
3461   int result;
3462   void *argp1 = 0 ;
3463   int res1 = 0 ;
3464   int res2 ;
3465   char *buf2 = 0 ;
3466   int alloc2 = 0 ;
3467   int res3 ;
3468   char *buf3 = 0 ;
3469   int alloc3 = 0 ;
3470   PyObject * obj0 = 0 ;
3471   PyObject * obj1 = 0 ;
3472   PyObject * obj2 = 0 ;
3473 
3474   if (!PyArg_ParseTuple(args,(char *)"OOO:netpgp_setvar",&obj0,&obj1,&obj2)) SWIG_fail;
3475   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3476   if (!SWIG_IsOK(res1)) {
3477     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_setvar" "', argument " "1"" of type '" "netpgp_t *""'");
3478   }
3479   arg1 = (netpgp_t *)(argp1);
3480   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3481   if (!SWIG_IsOK(res2)) {
3482     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_setvar" "', argument " "2"" of type '" "char const *""'");
3483   }
3484   arg2 = (char *)(buf2);
3485   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3486   if (!SWIG_IsOK(res3)) {
3487     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_setvar" "', argument " "3"" of type '" "char const *""'");
3488   }
3489   arg3 = (char *)(buf3);
3490   result = (int)netpgp_setvar(arg1,(char const *)arg2,(char const *)arg3);
3491   resultobj = SWIG_From_int((int)(result));
3492   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3493   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3494   return resultobj;
3495 fail:
3496   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3497   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3498   return NULL;
3499 }
3500 
3501 
3502 SWIGINTERN PyObject *_wrap_netpgp_getvar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3503   PyObject *resultobj = 0;
3504   netpgp_t *arg1 = (netpgp_t *) 0 ;
3505   char *arg2 = (char *) 0 ;
3506   char *result = 0 ;
3507   void *argp1 = 0 ;
3508   int res1 = 0 ;
3509   int res2 ;
3510   char *buf2 = 0 ;
3511   int alloc2 = 0 ;
3512   PyObject * obj0 = 0 ;
3513   PyObject * obj1 = 0 ;
3514 
3515   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_getvar",&obj0,&obj1)) SWIG_fail;
3516   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3517   if (!SWIG_IsOK(res1)) {
3518     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_getvar" "', argument " "1"" of type '" "netpgp_t *""'");
3519   }
3520   arg1 = (netpgp_t *)(argp1);
3521   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3522   if (!SWIG_IsOK(res2)) {
3523     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_getvar" "', argument " "2"" of type '" "char const *""'");
3524   }
3525   arg2 = (char *)(buf2);
3526   result = (char *)netpgp_getvar(arg1,(char const *)arg2);
3527   resultobj = SWIG_FromCharPtr((const char *)result);
3528   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3529   return resultobj;
3530 fail:
3531   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3532   return NULL;
3533 }
3534 
3535 
3536 SWIGINTERN PyObject *_wrap_netpgp_list_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3537   PyObject *resultobj = 0;
3538   netpgp_t *arg1 = (netpgp_t *) 0 ;
3539   int result;
3540   void *argp1 = 0 ;
3541   int res1 = 0 ;
3542   PyObject * obj0 = 0 ;
3543 
3544   if (!PyArg_ParseTuple(args,(char *)"O:netpgp_list_keys",&obj0)) SWIG_fail;
3545   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3546   if (!SWIG_IsOK(res1)) {
3547     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_list_keys" "', argument " "1"" of type '" "netpgp_t *""'");
3548   }
3549   arg1 = (netpgp_t *)(argp1);
3550   result = (int)netpgp_list_keys(arg1);
3551   resultobj = SWIG_From_int((int)(result));
3552   return resultobj;
3553 fail:
3554   return NULL;
3555 }
3556 
3557 
3558 SWIGINTERN PyObject *_wrap_netpgp_list_sigs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3559   PyObject *resultobj = 0;
3560   netpgp_t *arg1 = (netpgp_t *) 0 ;
3561   char *arg2 = (char *) 0 ;
3562   int result;
3563   void *argp1 = 0 ;
3564   int res1 = 0 ;
3565   int res2 ;
3566   char *buf2 = 0 ;
3567   int alloc2 = 0 ;
3568   PyObject * obj0 = 0 ;
3569   PyObject * obj1 = 0 ;
3570 
3571   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_list_sigs",&obj0,&obj1)) SWIG_fail;
3572   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3573   if (!SWIG_IsOK(res1)) {
3574     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_list_sigs" "', argument " "1"" of type '" "netpgp_t *""'");
3575   }
3576   arg1 = (netpgp_t *)(argp1);
3577   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3578   if (!SWIG_IsOK(res2)) {
3579     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_list_sigs" "', argument " "2"" of type '" "char const *""'");
3580   }
3581   arg2 = (char *)(buf2);
3582   result = (int)netpgp_list_sigs(arg1,(char const *)arg2);
3583   resultobj = SWIG_From_int((int)(result));
3584   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3585   return resultobj;
3586 fail:
3587   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3588   return NULL;
3589 }
3590 
3591 
3592 SWIGINTERN PyObject *_wrap_netpgp_find_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3593   PyObject *resultobj = 0;
3594   netpgp_t *arg1 = (netpgp_t *) 0 ;
3595   char *arg2 = (char *) 0 ;
3596   int result;
3597   void *argp1 = 0 ;
3598   int res1 = 0 ;
3599   int res2 ;
3600   char *buf2 = 0 ;
3601   int alloc2 = 0 ;
3602   PyObject * obj0 = 0 ;
3603   PyObject * obj1 = 0 ;
3604 
3605   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_find_key",&obj0,&obj1)) SWIG_fail;
3606   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3607   if (!SWIG_IsOK(res1)) {
3608     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_find_key" "', argument " "1"" of type '" "netpgp_t *""'");
3609   }
3610   arg1 = (netpgp_t *)(argp1);
3611   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3612   if (!SWIG_IsOK(res2)) {
3613     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_find_key" "', argument " "2"" of type '" "char *""'");
3614   }
3615   arg2 = (char *)(buf2);
3616   result = (int)netpgp_find_key(arg1,arg2);
3617   resultobj = SWIG_From_int((int)(result));
3618   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3619   return resultobj;
3620 fail:
3621   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3622   return NULL;
3623 }
3624 
3625 
3626 SWIGINTERN PyObject *_wrap_netpgp_get_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3627   PyObject *resultobj = 0;
3628   netpgp_t *arg1 = (netpgp_t *) 0 ;
3629   char *arg2 = (char *) 0 ;
3630   char *result = 0 ;
3631   void *argp1 = 0 ;
3632   int res1 = 0 ;
3633   int res2 ;
3634   char *buf2 = 0 ;
3635   int alloc2 = 0 ;
3636   PyObject * obj0 = 0 ;
3637   PyObject * obj1 = 0 ;
3638 
3639   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_get_key",&obj0,&obj1)) SWIG_fail;
3640   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3641   if (!SWIG_IsOK(res1)) {
3642     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_get_key" "', argument " "1"" of type '" "netpgp_t *""'");
3643   }
3644   arg1 = (netpgp_t *)(argp1);
3645   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3646   if (!SWIG_IsOK(res2)) {
3647     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_get_key" "', argument " "2"" of type '" "char const *""'");
3648   }
3649   arg2 = (char *)(buf2);
3650   result = (char *)netpgp_get_key(arg1,(char const *)arg2);
3651   resultobj = SWIG_FromCharPtr((const char *)result);
3652   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3653   return resultobj;
3654 fail:
3655   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3656   return NULL;
3657 }
3658 
3659 
3660 SWIGINTERN PyObject *_wrap_netpgp_export_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3661   PyObject *resultobj = 0;
3662   netpgp_t *arg1 = (netpgp_t *) 0 ;
3663   char *arg2 = (char *) 0 ;
3664   int result;
3665   void *argp1 = 0 ;
3666   int res1 = 0 ;
3667   int res2 ;
3668   char *buf2 = 0 ;
3669   int alloc2 = 0 ;
3670   PyObject * obj0 = 0 ;
3671   PyObject * obj1 = 0 ;
3672 
3673   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_export_key",&obj0,&obj1)) SWIG_fail;
3674   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3675   if (!SWIG_IsOK(res1)) {
3676     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_export_key" "', argument " "1"" of type '" "netpgp_t *""'");
3677   }
3678   arg1 = (netpgp_t *)(argp1);
3679   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3680   if (!SWIG_IsOK(res2)) {
3681     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_export_key" "', argument " "2"" of type '" "char *""'");
3682   }
3683   arg2 = (char *)(buf2);
3684   result = (int)netpgp_export_key(arg1,arg2);
3685   resultobj = SWIG_From_int((int)(result));
3686   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3687   return resultobj;
3688 fail:
3689   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3690   return NULL;
3691 }
3692 
3693 
3694 SWIGINTERN PyObject *_wrap_netpgp_import_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3695   PyObject *resultobj = 0;
3696   netpgp_t *arg1 = (netpgp_t *) 0 ;
3697   char *arg2 = (char *) 0 ;
3698   int result;
3699   void *argp1 = 0 ;
3700   int res1 = 0 ;
3701   int res2 ;
3702   char *buf2 = 0 ;
3703   int alloc2 = 0 ;
3704   PyObject * obj0 = 0 ;
3705   PyObject * obj1 = 0 ;
3706 
3707   if (!PyArg_ParseTuple(args,(char *)"OO:netpgp_import_key",&obj0,&obj1)) SWIG_fail;
3708   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3709   if (!SWIG_IsOK(res1)) {
3710     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_import_key" "', argument " "1"" of type '" "netpgp_t *""'");
3711   }
3712   arg1 = (netpgp_t *)(argp1);
3713   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3714   if (!SWIG_IsOK(res2)) {
3715     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_import_key" "', argument " "2"" of type '" "char *""'");
3716   }
3717   arg2 = (char *)(buf2);
3718   result = (int)netpgp_import_key(arg1,arg2);
3719   resultobj = SWIG_From_int((int)(result));
3720   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3721   return resultobj;
3722 fail:
3723   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3724   return NULL;
3725 }
3726 
3727 
3728 SWIGINTERN PyObject *_wrap_netpgp_generate_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3729   PyObject *resultobj = 0;
3730   netpgp_t *arg1 = (netpgp_t *) 0 ;
3731   char *arg2 = (char *) 0 ;
3732   int arg3 ;
3733   int result;
3734   void *argp1 = 0 ;
3735   int res1 = 0 ;
3736   int res2 ;
3737   char *buf2 = 0 ;
3738   int alloc2 = 0 ;
3739   int val3 ;
3740   int ecode3 = 0 ;
3741   PyObject * obj0 = 0 ;
3742   PyObject * obj1 = 0 ;
3743   PyObject * obj2 = 0 ;
3744 
3745   if (!PyArg_ParseTuple(args,(char *)"OOO:netpgp_generate_key",&obj0,&obj1,&obj2)) SWIG_fail;
3746   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3747   if (!SWIG_IsOK(res1)) {
3748     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_generate_key" "', argument " "1"" of type '" "netpgp_t *""'");
3749   }
3750   arg1 = (netpgp_t *)(argp1);
3751   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3752   if (!SWIG_IsOK(res2)) {
3753     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_generate_key" "', argument " "2"" of type '" "char *""'");
3754   }
3755   arg2 = (char *)(buf2);
3756   ecode3 = SWIG_AsVal_int(obj2, &val3);
3757   if (!SWIG_IsOK(ecode3)) {
3758     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "netpgp_generate_key" "', argument " "3"" of type '" "int""'");
3759   }
3760   arg3 = (int)(val3);
3761   result = (int)netpgp_generate_key(arg1,arg2,arg3);
3762   resultobj = SWIG_From_int((int)(result));
3763   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3764   return resultobj;
3765 fail:
3766   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3767   return NULL;
3768 }
3769 
3770 
3771 SWIGINTERN PyObject *_wrap_netpgp_encrypt_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3772   PyObject *resultobj = 0;
3773   netpgp_t *arg1 = (netpgp_t *) 0 ;
3774   char *arg2 = (char *) 0 ;
3775   char *arg3 = (char *) 0 ;
3776   char *arg4 = (char *) 0 ;
3777   int arg5 ;
3778   int result;
3779   void *argp1 = 0 ;
3780   int res1 = 0 ;
3781   int res2 ;
3782   char *buf2 = 0 ;
3783   int alloc2 = 0 ;
3784   int res3 ;
3785   char *buf3 = 0 ;
3786   int alloc3 = 0 ;
3787   int res4 ;
3788   char *buf4 = 0 ;
3789   int alloc4 = 0 ;
3790   int val5 ;
3791   int ecode5 = 0 ;
3792   PyObject * obj0 = 0 ;
3793   PyObject * obj1 = 0 ;
3794   PyObject * obj2 = 0 ;
3795   PyObject * obj3 = 0 ;
3796   PyObject * obj4 = 0 ;
3797 
3798   if (!PyArg_ParseTuple(args,(char *)"OOOOO:netpgp_encrypt_file",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
3799   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3800   if (!SWIG_IsOK(res1)) {
3801     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_encrypt_file" "', argument " "1"" of type '" "netpgp_t *""'");
3802   }
3803   arg1 = (netpgp_t *)(argp1);
3804   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3805   if (!SWIG_IsOK(res2)) {
3806     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_encrypt_file" "', argument " "2"" of type '" "char const *""'");
3807   }
3808   arg2 = (char *)(buf2);
3809   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3810   if (!SWIG_IsOK(res3)) {
3811     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_encrypt_file" "', argument " "3"" of type '" "char const *""'");
3812   }
3813   arg3 = (char *)(buf3);
3814   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
3815   if (!SWIG_IsOK(res4)) {
3816     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "netpgp_encrypt_file" "', argument " "4"" of type '" "char *""'");
3817   }
3818   arg4 = (char *)(buf4);
3819   ecode5 = SWIG_AsVal_int(obj4, &val5);
3820   if (!SWIG_IsOK(ecode5)) {
3821     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "netpgp_encrypt_file" "', argument " "5"" of type '" "int""'");
3822   }
3823   arg5 = (int)(val5);
3824   result = (int)netpgp_encrypt_file(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
3825   resultobj = SWIG_From_int((int)(result));
3826   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3827   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3828   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3829   return resultobj;
3830 fail:
3831   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3832   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3833   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3834   return NULL;
3835 }
3836 
3837 
3838 SWIGINTERN PyObject *_wrap_netpgp_decrypt_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3839   PyObject *resultobj = 0;
3840   netpgp_t *arg1 = (netpgp_t *) 0 ;
3841   char *arg2 = (char *) 0 ;
3842   char *arg3 = (char *) 0 ;
3843   int arg4 ;
3844   int result;
3845   void *argp1 = 0 ;
3846   int res1 = 0 ;
3847   int res2 ;
3848   char *buf2 = 0 ;
3849   int alloc2 = 0 ;
3850   int res3 ;
3851   char *buf3 = 0 ;
3852   int alloc3 = 0 ;
3853   int val4 ;
3854   int ecode4 = 0 ;
3855   PyObject * obj0 = 0 ;
3856   PyObject * obj1 = 0 ;
3857   PyObject * obj2 = 0 ;
3858   PyObject * obj3 = 0 ;
3859 
3860   if (!PyArg_ParseTuple(args,(char *)"OOOO:netpgp_decrypt_file",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3861   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3862   if (!SWIG_IsOK(res1)) {
3863     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_decrypt_file" "', argument " "1"" of type '" "netpgp_t *""'");
3864   }
3865   arg1 = (netpgp_t *)(argp1);
3866   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3867   if (!SWIG_IsOK(res2)) {
3868     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_decrypt_file" "', argument " "2"" of type '" "char const *""'");
3869   }
3870   arg2 = (char *)(buf2);
3871   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3872   if (!SWIG_IsOK(res3)) {
3873     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_decrypt_file" "', argument " "3"" of type '" "char *""'");
3874   }
3875   arg3 = (char *)(buf3);
3876   ecode4 = SWIG_AsVal_int(obj3, &val4);
3877   if (!SWIG_IsOK(ecode4)) {
3878     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_decrypt_file" "', argument " "4"" of type '" "int""'");
3879   }
3880   arg4 = (int)(val4);
3881   result = (int)netpgp_decrypt_file(arg1,(char const *)arg2,arg3,arg4);
3882   resultobj = SWIG_From_int((int)(result));
3883   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3884   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3885   return resultobj;
3886 fail:
3887   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3888   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3889   return NULL;
3890 }
3891 
3892 
3893 SWIGINTERN PyObject *_wrap_netpgp_sign_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3894   PyObject *resultobj = 0;
3895   netpgp_t *arg1 = (netpgp_t *) 0 ;
3896   char *arg2 = (char *) 0 ;
3897   char *arg3 = (char *) 0 ;
3898   char *arg4 = (char *) 0 ;
3899   int arg5 ;
3900   int arg6 ;
3901   int arg7 ;
3902   int result;
3903   void *argp1 = 0 ;
3904   int res1 = 0 ;
3905   int res2 ;
3906   char *buf2 = 0 ;
3907   int alloc2 = 0 ;
3908   int res3 ;
3909   char *buf3 = 0 ;
3910   int alloc3 = 0 ;
3911   int res4 ;
3912   char *buf4 = 0 ;
3913   int alloc4 = 0 ;
3914   int val5 ;
3915   int ecode5 = 0 ;
3916   int val6 ;
3917   int ecode6 = 0 ;
3918   int val7 ;
3919   int ecode7 = 0 ;
3920   PyObject * obj0 = 0 ;
3921   PyObject * obj1 = 0 ;
3922   PyObject * obj2 = 0 ;
3923   PyObject * obj3 = 0 ;
3924   PyObject * obj4 = 0 ;
3925   PyObject * obj5 = 0 ;
3926   PyObject * obj6 = 0 ;
3927 
3928   if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:netpgp_sign_file",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
3929   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3930   if (!SWIG_IsOK(res1)) {
3931     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_sign_file" "', argument " "1"" of type '" "netpgp_t *""'");
3932   }
3933   arg1 = (netpgp_t *)(argp1);
3934   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3935   if (!SWIG_IsOK(res2)) {
3936     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_sign_file" "', argument " "2"" of type '" "char const *""'");
3937   }
3938   arg2 = (char *)(buf2);
3939   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
3940   if (!SWIG_IsOK(res3)) {
3941     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_sign_file" "', argument " "3"" of type '" "char const *""'");
3942   }
3943   arg3 = (char *)(buf3);
3944   res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
3945   if (!SWIG_IsOK(res4)) {
3946     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "netpgp_sign_file" "', argument " "4"" of type '" "char *""'");
3947   }
3948   arg4 = (char *)(buf4);
3949   ecode5 = SWIG_AsVal_int(obj4, &val5);
3950   if (!SWIG_IsOK(ecode5)) {
3951     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "netpgp_sign_file" "', argument " "5"" of type '" "int""'");
3952   }
3953   arg5 = (int)(val5);
3954   ecode6 = SWIG_AsVal_int(obj5, &val6);
3955   if (!SWIG_IsOK(ecode6)) {
3956     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "netpgp_sign_file" "', argument " "6"" of type '" "int""'");
3957   }
3958   arg6 = (int)(val6);
3959   ecode7 = SWIG_AsVal_int(obj6, &val7);
3960   if (!SWIG_IsOK(ecode7)) {
3961     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "netpgp_sign_file" "', argument " "7"" of type '" "int""'");
3962   }
3963   arg7 = (int)(val7);
3964   result = (int)netpgp_sign_file(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7);
3965   resultobj = SWIG_From_int((int)(result));
3966   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3967   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3968   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3969   return resultobj;
3970 fail:
3971   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3972   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3973   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3974   return NULL;
3975 }
3976 
3977 
3978 SWIGINTERN PyObject *_wrap_netpgp_verify_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3979   PyObject *resultobj = 0;
3980   netpgp_t *arg1 = (netpgp_t *) 0 ;
3981   char *arg2 = (char *) 0 ;
3982   char *arg3 = (char *) 0 ;
3983   int arg4 ;
3984   int result;
3985   void *argp1 = 0 ;
3986   int res1 = 0 ;
3987   int res2 ;
3988   char *buf2 = 0 ;
3989   int alloc2 = 0 ;
3990   int res3 ;
3991   char *buf3 = 0 ;
3992   int alloc3 = 0 ;
3993   int val4 ;
3994   int ecode4 = 0 ;
3995   PyObject * obj0 = 0 ;
3996   PyObject * obj1 = 0 ;
3997   PyObject * obj2 = 0 ;
3998   PyObject * obj3 = 0 ;
3999 
4000   if (!PyArg_ParseTuple(args,(char *)"OOOO:netpgp_verify_file",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4001   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
4002   if (!SWIG_IsOK(res1)) {
4003     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_verify_file" "', argument " "1"" of type '" "netpgp_t *""'");
4004   }
4005   arg1 = (netpgp_t *)(argp1);
4006   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4007   if (!SWIG_IsOK(res2)) {
4008     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_verify_file" "', argument " "2"" of type '" "char const *""'");
4009   }
4010   arg2 = (char *)(buf2);
4011   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
4012   if (!SWIG_IsOK(res3)) {
4013     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_verify_file" "', argument " "3"" of type '" "char const *""'");
4014   }
4015   arg3 = (char *)(buf3);
4016   ecode4 = SWIG_AsVal_int(obj3, &val4);
4017   if (!SWIG_IsOK(ecode4)) {
4018     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_verify_file" "', argument " "4"" of type '" "int""'");
4019   }
4020   arg4 = (int)(val4);
4021   result = (int)netpgp_verify_file(arg1,(char const *)arg2,(char const *)arg3,arg4);
4022   resultobj = SWIG_From_int((int)(result));
4023   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4024   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4025   return resultobj;
4026 fail:
4027   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4028   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4029   return NULL;
4030 }
4031 
4032 
4033 SWIGINTERN PyObject *_wrap_netpgp_sign_memory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4034   PyObject *resultobj = 0;
4035   netpgp_t *arg1 = (netpgp_t *) 0 ;
4036   char *arg2 = (char *) 0 ;
4037   char *arg3 = (char *) 0 ;
4038   size_t arg4 ;
4039   char *arg5 = (char *) 0 ;
4040   size_t arg6 ;
4041   unsigned int arg7 ;
4042   unsigned int arg8 ;
4043   int result;
4044   void *argp1 = 0 ;
4045   int res1 = 0 ;
4046   int res2 ;
4047   char *buf2 = 0 ;
4048   int alloc2 = 0 ;
4049   int res3 ;
4050   char *buf3 = 0 ;
4051   int alloc3 = 0 ;
4052   size_t val4 ;
4053   int ecode4 = 0 ;
4054   int res5 ;
4055   char *buf5 = 0 ;
4056   int alloc5 = 0 ;
4057   size_t val6 ;
4058   int ecode6 = 0 ;
4059   unsigned int val7 ;
4060   int ecode7 = 0 ;
4061   unsigned int val8 ;
4062   int ecode8 = 0 ;
4063   PyObject * obj0 = 0 ;
4064   PyObject * obj1 = 0 ;
4065   PyObject * obj2 = 0 ;
4066   PyObject * obj3 = 0 ;
4067   PyObject * obj4 = 0 ;
4068   PyObject * obj5 = 0 ;
4069   PyObject * obj6 = 0 ;
4070   PyObject * obj7 = 0 ;
4071 
4072   if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:netpgp_sign_memory",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
4073   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
4074   if (!SWIG_IsOK(res1)) {
4075     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_sign_memory" "', argument " "1"" of type '" "netpgp_t *""'");
4076   }
4077   arg1 = (netpgp_t *)(argp1);
4078   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4079   if (!SWIG_IsOK(res2)) {
4080     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_sign_memory" "', argument " "2"" of type '" "char const *""'");
4081   }
4082   arg2 = (char *)(buf2);
4083   res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
4084   if (!SWIG_IsOK(res3)) {
4085     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_sign_memory" "', argument " "3"" of type '" "char *""'");
4086   }
4087   arg3 = (char *)(buf3);
4088   ecode4 = SWIG_AsVal_size_t(obj3, &val4);
4089   if (!SWIG_IsOK(ecode4)) {
4090     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_sign_memory" "', argument " "4"" of type '" "size_t""'");
4091   }
4092   arg4 = (size_t)(val4);
4093   res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
4094   if (!SWIG_IsOK(res5)) {
4095     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "netpgp_sign_memory" "', argument " "5"" of type '" "char *""'");
4096   }
4097   arg5 = (char *)(buf5);
4098   ecode6 = SWIG_AsVal_size_t(obj5, &val6);
4099   if (!SWIG_IsOK(ecode6)) {
4100     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "netpgp_sign_memory" "', argument " "6"" of type '" "size_t""'");
4101   }
4102   arg6 = (size_t)(val6);
4103   ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
4104   if (!SWIG_IsOK(ecode7)) {
4105     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "netpgp_sign_memory" "', argument " "7"" of type '" "unsigned int""'");
4106   }
4107   arg7 = (unsigned int)(val7);
4108   ecode8 = SWIG_AsVal_unsigned_SS_int(obj7, &val8);
4109   if (!SWIG_IsOK(ecode8)) {
4110     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "netpgp_sign_memory" "', argument " "8"" of type '" "unsigned int""'");
4111   }
4112   arg8 = (unsigned int)(val8);
4113   result = (int)netpgp_sign_memory(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
4114   resultobj = SWIG_From_int((int)(result));
4115   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4116   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4117   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
4118   return resultobj;
4119 fail:
4120   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4121   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
4122   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
4123   return NULL;
4124 }
4125 
4126 
4127 SWIGINTERN PyObject *_wrap_netpgp_verify_memory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4128   PyObject *resultobj = 0;
4129   netpgp_t *arg1 = (netpgp_t *) 0 ;
4130   void *arg2 = (void *) 0 ;
4131   size_t arg3 ;
4132   int arg4 ;
4133   int result;
4134   void *argp1 = 0 ;
4135   int res1 = 0 ;
4136   int res2 ;
4137   size_t val3 ;
4138   int ecode3 = 0 ;
4139   int val4 ;
4140   int ecode4 = 0 ;
4141   PyObject * obj0 = 0 ;
4142   PyObject * obj1 = 0 ;
4143   PyObject * obj2 = 0 ;
4144   PyObject * obj3 = 0 ;
4145 
4146   if (!PyArg_ParseTuple(args,(char *)"OOOO:netpgp_verify_memory",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4147   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
4148   if (!SWIG_IsOK(res1)) {
4149     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_verify_memory" "', argument " "1"" of type '" "netpgp_t *""'");
4150   }
4151   arg1 = (netpgp_t *)(argp1);
4152   res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
4153   if (!SWIG_IsOK(res2)) {
4154     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_verify_memory" "', argument " "2"" of type '" "void const *""'");
4155   }
4156   ecode3 = SWIG_AsVal_size_t(obj2, &val3);
4157   if (!SWIG_IsOK(ecode3)) {
4158     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "netpgp_verify_memory" "', argument " "3"" of type '" "size_t""'");
4159   }
4160   arg3 = (size_t)(val3);
4161   ecode4 = SWIG_AsVal_int(obj3, &val4);
4162   if (!SWIG_IsOK(ecode4)) {
4163     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_verify_memory" "', argument " "4"" of type '" "int""'");
4164   }
4165   arg4 = (int)(val4);
4166   result = (int)netpgp_verify_memory(arg1,(void const *)arg2,arg3,arg4);
4167   resultobj = SWIG_From_int((int)(result));
4168   return resultobj;
4169 fail:
4170   return NULL;
4171 }
4172 
4173 
4174 static PyMethodDef SwigMethods[] = {
4175 	 { (char *)"netpgp_t_c_set", _wrap_netpgp_t_c_set, METH_VARARGS, NULL},
4176 	 { (char *)"netpgp_t_c_get", _wrap_netpgp_t_c_get, METH_VARARGS, NULL},
4177 	 { (char *)"netpgp_t_size_set", _wrap_netpgp_t_size_set, METH_VARARGS, NULL},
4178 	 { (char *)"netpgp_t_size_get", _wrap_netpgp_t_size_get, METH_VARARGS, NULL},
4179 	 { (char *)"netpgp_t_name_set", _wrap_netpgp_t_name_set, METH_VARARGS, NULL},
4180 	 { (char *)"netpgp_t_name_get", _wrap_netpgp_t_name_get, METH_VARARGS, NULL},
4181 	 { (char *)"netpgp_t_value_set", _wrap_netpgp_t_value_set, METH_VARARGS, NULL},
4182 	 { (char *)"netpgp_t_value_get", _wrap_netpgp_t_value_get, METH_VARARGS, NULL},
4183 	 { (char *)"netpgp_t_pubring_set", _wrap_netpgp_t_pubring_set, METH_VARARGS, NULL},
4184 	 { (char *)"netpgp_t_pubring_get", _wrap_netpgp_t_pubring_get, METH_VARARGS, NULL},
4185 	 { (char *)"netpgp_t_secring_set", _wrap_netpgp_t_secring_set, METH_VARARGS, NULL},
4186 	 { (char *)"netpgp_t_secring_get", _wrap_netpgp_t_secring_get, METH_VARARGS, NULL},
4187 	 { (char *)"netpgp_t_io_set", _wrap_netpgp_t_io_set, METH_VARARGS, NULL},
4188 	 { (char *)"netpgp_t_io_get", _wrap_netpgp_t_io_get, METH_VARARGS, NULL},
4189 	 { (char *)"netpgp_t_passfp_set", _wrap_netpgp_t_passfp_set, METH_VARARGS, NULL},
4190 	 { (char *)"netpgp_t_passfp_get", _wrap_netpgp_t_passfp_get, METH_VARARGS, NULL},
4191 	 { (char *)"new_netpgp_t", _wrap_new_netpgp_t, METH_VARARGS, NULL},
4192 	 { (char *)"delete_netpgp_t", _wrap_delete_netpgp_t, METH_VARARGS, NULL},
4193 	 { (char *)"netpgp_t_swigregister", netpgp_t_swigregister, METH_VARARGS, NULL},
4194 	 { (char *)"netpgp_init", _wrap_netpgp_init, METH_VARARGS, NULL},
4195 	 { (char *)"netpgp_end", _wrap_netpgp_end, METH_VARARGS, NULL},
4196 	 { (char *)"netpgp_set_debug", _wrap_netpgp_set_debug, METH_VARARGS, NULL},
4197 	 { (char *)"netpgp_get_debug", _wrap_netpgp_get_debug, METH_VARARGS, NULL},
4198 	 { (char *)"netpgp_get_info", _wrap_netpgp_get_info, METH_VARARGS, NULL},
4199 	 { (char *)"netpgp_list_packets", _wrap_netpgp_list_packets, METH_VARARGS, NULL},
4200 	 { (char *)"netpgp_setvar", _wrap_netpgp_setvar, METH_VARARGS, NULL},
4201 	 { (char *)"netpgp_getvar", _wrap_netpgp_getvar, METH_VARARGS, NULL},
4202 	 { (char *)"netpgp_list_keys", _wrap_netpgp_list_keys, METH_VARARGS, NULL},
4203 	 { (char *)"netpgp_list_sigs", _wrap_netpgp_list_sigs, METH_VARARGS, NULL},
4204 	 { (char *)"netpgp_find_key", _wrap_netpgp_find_key, METH_VARARGS, NULL},
4205 	 { (char *)"netpgp_get_key", _wrap_netpgp_get_key, METH_VARARGS, NULL},
4206 	 { (char *)"netpgp_export_key", _wrap_netpgp_export_key, METH_VARARGS, NULL},
4207 	 { (char *)"netpgp_import_key", _wrap_netpgp_import_key, METH_VARARGS, NULL},
4208 	 { (char *)"netpgp_generate_key", _wrap_netpgp_generate_key, METH_VARARGS, NULL},
4209 	 { (char *)"netpgp_encrypt_file", _wrap_netpgp_encrypt_file, METH_VARARGS, NULL},
4210 	 { (char *)"netpgp_decrypt_file", _wrap_netpgp_decrypt_file, METH_VARARGS, NULL},
4211 	 { (char *)"netpgp_sign_file", _wrap_netpgp_sign_file, METH_VARARGS, NULL},
4212 	 { (char *)"netpgp_verify_file", _wrap_netpgp_verify_file, METH_VARARGS, NULL},
4213 	 { (char *)"netpgp_sign_memory", _wrap_netpgp_sign_memory, METH_VARARGS, NULL},
4214 	 { (char *)"netpgp_verify_memory", _wrap_netpgp_verify_memory, METH_VARARGS, NULL},
4215 	 { NULL, NULL, 0, NULL }
4216 };
4217 
4218 
4219 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4220 
4221 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
4222 static swig_type_info _swigt__p_netpgp_t = {"_p_netpgp_t", "struct netpgp_t *|netpgp_t *", 0, 0, (void*)0, 0};
4223 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
4224 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
4225 
4226 static swig_type_info *swig_type_initial[] = {
4227   &_swigt__p_char,
4228   &_swigt__p_netpgp_t,
4229   &_swigt__p_p_char,
4230   &_swigt__p_void,
4231 };
4232 
4233 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
4234 static swig_cast_info _swigc__p_netpgp_t[] = {  {&_swigt__p_netpgp_t, 0, 0, 0},{0, 0, 0, 0}};
4235 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
4236 static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
4237 
4238 static swig_cast_info *swig_cast_initial[] = {
4239   _swigc__p_char,
4240   _swigc__p_netpgp_t,
4241   _swigc__p_p_char,
4242   _swigc__p_void,
4243 };
4244 
4245 
4246 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4247 
4248 static swig_const_info swig_const_table[] = {
4249 {0, 0, 0, 0.0, 0, 0}};
4250 
4251 #ifdef __cplusplus
4252 }
4253 #endif
4254 /* -----------------------------------------------------------------------------
4255  * Type initialization:
4256  * This problem is tough by the requirement that no dynamic
4257  * memory is used. Also, since swig_type_info structures store pointers to
4258  * swig_cast_info structures and swig_cast_info structures store pointers back
4259  * to swig_type_info structures, we need some lookup code at initialization.
4260  * The idea is that swig generates all the structures that are needed.
4261  * The runtime then collects these partially filled structures.
4262  * The SWIG_InitializeModule function takes these initial arrays out of
4263  * swig_module, and does all the lookup, filling in the swig_module.types
4264  * array with the correct data and linking the correct swig_cast_info
4265  * structures together.
4266  *
4267  * The generated swig_type_info structures are assigned staticly to an initial
4268  * array. We just loop through that array, and handle each type individually.
4269  * First we lookup if this type has been already loaded, and if so, use the
4270  * loaded structure instead of the generated one. Then we have to fill in the
4271  * cast linked list. The cast data is initially stored in something like a
4272  * two-dimensional array. Each row corresponds to a type (there are the same
4273  * number of rows as there are in the swig_type_initial array). Each entry in
4274  * a column is one of the swig_cast_info structures for that type.
4275  * The cast_initial array is actually an array of arrays, because each row has
4276  * a variable number of columns. So to actually build the cast linked list,
4277  * we find the array of casts associated with the type, and loop through it
4278  * adding the casts to the list. The one last trick we need to do is making
4279  * sure the type pointer in the swig_cast_info struct is correct.
4280  *
4281  * First off, we lookup the cast->type name to see if it is already loaded.
4282  * There are three cases to handle:
4283  *  1) If the cast->type has already been loaded AND the type we are adding
4284  *     casting info to has not been loaded (it is in this module), THEN we
4285  *     replace the cast->type pointer with the type pointer that has already
4286  *     been loaded.
4287  *  2) If BOTH types (the one we are adding casting info to, and the
4288  *     cast->type) are loaded, THEN the cast info has already been loaded by
4289  *     the previous module so we just ignore it.
4290  *  3) Finally, if cast->type has not already been loaded, then we add that
4291  *     swig_cast_info to the linked list (because the cast->type) pointer will
4292  *     be correct.
4293  * ----------------------------------------------------------------------------- */
4294 
4295 #ifdef __cplusplus
4296 extern "C" {
4297 #if 0
4298 } /* c-mode */
4299 #endif
4300 #endif
4301 
4302 #if 0
4303 #define SWIGRUNTIME_DEBUG
4304 #endif
4305 
4306 
4307 SWIGRUNTIME void
4308 SWIG_InitializeModule(void *clientdata) {
4309   size_t i;
4310   swig_module_info *module_head, *iter;
4311   int found;
4312 
4313   clientdata = clientdata;
4314 
4315   /* check to see if the circular list has been setup, if not, set it up */
4316   if (swig_module.next==0) {
4317     /* Initialize the swig_module */
4318     swig_module.type_initial = swig_type_initial;
4319     swig_module.cast_initial = swig_cast_initial;
4320     swig_module.next = &swig_module;
4321   }
4322 
4323   /* Try and load any already created modules */
4324   module_head = SWIG_GetModule(clientdata);
4325   if (!module_head) {
4326     /* This is the first module loaded for this interpreter */
4327     /* so set the swig module into the interpreter */
4328     SWIG_SetModule(clientdata, &swig_module);
4329     module_head = &swig_module;
4330   } else {
4331     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4332     found=0;
4333     iter=module_head;
4334     do {
4335       if (iter==&swig_module) {
4336         found=1;
4337         break;
4338       }
4339       iter=iter->next;
4340     } while (iter!= module_head);
4341 
4342     /* if the is found in the list, then all is done and we may leave */
4343     if (found) return;
4344     /* otherwise we must add out module into the list */
4345     swig_module.next = module_head->next;
4346     module_head->next = &swig_module;
4347   }
4348 
4349   /* Now work on filling in swig_module.types */
4350 #ifdef SWIGRUNTIME_DEBUG
4351   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
4352 #endif
4353   for (i = 0; i < swig_module.size; ++i) {
4354     swig_type_info *type = 0;
4355     swig_type_info *ret;
4356     swig_cast_info *cast;
4357 
4358 #ifdef SWIGRUNTIME_DEBUG
4359     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4360 #endif
4361 
4362     /* if there is another module already loaded */
4363     if (swig_module.next != &swig_module) {
4364       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4365     }
4366     if (type) {
4367       /* Overwrite clientdata field */
4368 #ifdef SWIGRUNTIME_DEBUG
4369       printf("SWIG_InitializeModule: found type %s\n", type->name);
4370 #endif
4371       if (swig_module.type_initial[i]->clientdata) {
4372         type->clientdata = swig_module.type_initial[i]->clientdata;
4373 #ifdef SWIGRUNTIME_DEBUG
4374         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
4375 #endif
4376       }
4377     } else {
4378       type = swig_module.type_initial[i];
4379     }
4380 
4381     /* Insert casting types */
4382     cast = swig_module.cast_initial[i];
4383     while (cast->type) {
4384       /* Don't need to add information already in the list */
4385       ret = 0;
4386 #ifdef SWIGRUNTIME_DEBUG
4387       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4388 #endif
4389       if (swig_module.next != &swig_module) {
4390         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4391 #ifdef SWIGRUNTIME_DEBUG
4392         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4393 #endif
4394       }
4395       if (ret) {
4396         if (type == swig_module.type_initial[i]) {
4397 #ifdef SWIGRUNTIME_DEBUG
4398           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4399 #endif
4400           cast->type = ret;
4401           ret = 0;
4402         } else {
4403           /* Check for casting already in the list */
4404           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4405 #ifdef SWIGRUNTIME_DEBUG
4406           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4407 #endif
4408           if (!ocast) ret = 0;
4409         }
4410       }
4411 
4412       if (!ret) {
4413 #ifdef SWIGRUNTIME_DEBUG
4414         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4415 #endif
4416         if (type->cast) {
4417           type->cast->prev = cast;
4418           cast->next = type->cast;
4419         }
4420         type->cast = cast;
4421       }
4422       cast++;
4423     }
4424     /* Set entry in modules->types array equal to the type */
4425     swig_module.types[i] = type;
4426   }
4427   swig_module.types[i] = 0;
4428 
4429 #ifdef SWIGRUNTIME_DEBUG
4430   printf("**** SWIG_InitializeModule: Cast List ******\n");
4431   for (i = 0; i < swig_module.size; ++i) {
4432     int j = 0;
4433     swig_cast_info *cast = swig_module.cast_initial[i];
4434     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4435     while (cast->type) {
4436       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4437       cast++;
4438       ++j;
4439     }
4440     printf("---- Total casts: %d\n",j);
4441   }
4442   printf("**** SWIG_InitializeModule: Cast List ******\n");
4443 #endif
4444 }
4445 
4446 /* This function will propagate the clientdata field of type to
4447 * any new swig_type_info structures that have been added into the list
4448 * of equivalent types.  It is like calling
4449 * SWIG_TypeClientData(type, clientdata) a second time.
4450 */
4451 SWIGRUNTIME void
4452 SWIG_PropagateClientData(void) {
4453   size_t i;
4454   swig_cast_info *equiv;
4455   static int init_run = 0;
4456 
4457   if (init_run) return;
4458   init_run = 1;
4459 
4460   for (i = 0; i < swig_module.size; i++) {
4461     if (swig_module.types[i]->clientdata) {
4462       equiv = swig_module.types[i]->cast;
4463       while (equiv) {
4464         if (!equiv->converter) {
4465           if (equiv->type && !equiv->type->clientdata)
4466           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4467         }
4468         equiv = equiv->next;
4469       }
4470     }
4471   }
4472 }
4473 
4474 #ifdef __cplusplus
4475 #if 0
4476 {
4477   /* c-mode */
4478 #endif
4479 }
4480 #endif
4481 
4482 
4483 
4484 #ifdef __cplusplus
4485 extern "C" {
4486 #endif
4487 
4488   /* Python-specific SWIG API */
4489 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
4490 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
4491 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
4492 
4493   /* -----------------------------------------------------------------------------
4494    * global variable support code.
4495    * ----------------------------------------------------------------------------- */
4496 
4497   typedef struct swig_globalvar {
4498     char       *name;                  /* Name of global variable */
4499     PyObject *(*get_attr)(void);       /* Return the current value */
4500     int       (*set_attr)(PyObject *); /* Set the value */
4501     struct swig_globalvar *next;
4502   } swig_globalvar;
4503 
4504   typedef struct swig_varlinkobject {
4505     PyObject_HEAD
4506     swig_globalvar *vars;
4507   } swig_varlinkobject;
4508 
4509   SWIGINTERN PyObject *
4510   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
4511     return PyString_FromString("<Swig global variables>");
4512   }
4513 
4514   SWIGINTERN PyObject *
4515   swig_varlink_str(swig_varlinkobject *v) {
4516     PyObject *str = PyString_FromString("(");
4517     swig_globalvar  *var;
4518     for (var = v->vars; var; var=var->next) {
4519       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
4520       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
4521     }
4522     PyString_ConcatAndDel(&str,PyString_FromString(")"));
4523     return str;
4524   }
4525 
4526   SWIGINTERN int
4527   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
4528     PyObject *str = swig_varlink_str(v);
4529     fprintf(fp,"Swig global variables ");
4530     fprintf(fp,"%s\n", PyString_AsString(str));
4531     Py_DECREF(str);
4532     return 0;
4533   }
4534 
4535   SWIGINTERN void
4536   swig_varlink_dealloc(swig_varlinkobject *v) {
4537     swig_globalvar *var = v->vars;
4538     while (var) {
4539       swig_globalvar *n = var->next;
4540       free(var->name);
4541       free(var);
4542       var = n;
4543     }
4544   }
4545 
4546   SWIGINTERN PyObject *
4547   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
4548     PyObject *res = NULL;
4549     swig_globalvar *var = v->vars;
4550     while (var) {
4551       if (strcmp(var->name,n) == 0) {
4552         res = (*var->get_attr)();
4553         break;
4554       }
4555       var = var->next;
4556     }
4557     if (res == NULL && !PyErr_Occurred()) {
4558       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
4559     }
4560     return res;
4561   }
4562 
4563   SWIGINTERN int
4564   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
4565     int res = 1;
4566     swig_globalvar *var = v->vars;
4567     while (var) {
4568       if (strcmp(var->name,n) == 0) {
4569         res = (*var->set_attr)(p);
4570         break;
4571       }
4572       var = var->next;
4573     }
4574     if (res == 1 && !PyErr_Occurred()) {
4575       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
4576     }
4577     return res;
4578   }
4579 
4580   SWIGINTERN PyTypeObject*
4581   swig_varlink_type(void) {
4582     static char varlink__doc__[] = "Swig var link object";
4583     static PyTypeObject varlink_type;
4584     static int type_init = 0;
4585     if (!type_init) {
4586       const PyTypeObject tmp
4587       = {
4588         PyObject_HEAD_INIT(NULL)
4589         0,                                  /* Number of items in variable part (ob_size) */
4590         (char *)"swigvarlink",              /* Type name (tp_name) */
4591         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
4592         0,                                  /* Itemsize (tp_itemsize) */
4593         (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */
4594         (printfunc) swig_varlink_print,     /* Print (tp_print) */
4595         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
4596         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
4597         0,                                  /* tp_compare */
4598         (reprfunc) swig_varlink_repr,       /* tp_repr */
4599         0,                                  /* tp_as_number */
4600         0,                                  /* tp_as_sequence */
4601         0,                                  /* tp_as_mapping */
4602         0,                                  /* tp_hash */
4603         0,                                  /* tp_call */
4604         (reprfunc)swig_varlink_str,        /* tp_str */
4605         0,                                  /* tp_getattro */
4606         0,                                  /* tp_setattro */
4607         0,                                  /* tp_as_buffer */
4608         0,                                  /* tp_flags */
4609         varlink__doc__,                     /* tp_doc */
4610         0,                                  /* tp_traverse */
4611         0,                                  /* tp_clear */
4612         0,                                  /* tp_richcompare */
4613         0,                                  /* tp_weaklistoffset */
4614 #if PY_VERSION_HEX >= 0x02020000
4615         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
4616 #endif
4617 #if PY_VERSION_HEX >= 0x02030000
4618         0,                                  /* tp_del */
4619 #endif
4620 #ifdef COUNT_ALLOCS
4621         0,0,0,0                             /* tp_alloc -> tp_next */
4622 #endif
4623       };
4624       varlink_type = tmp;
4625       varlink_type.ob_type = &PyType_Type;
4626       type_init = 1;
4627     }
4628     return &varlink_type;
4629   }
4630 
4631   /* Create a variable linking object for use later */
4632   SWIGINTERN PyObject *
4633   SWIG_Python_newvarlink(void) {
4634     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
4635     if (result) {
4636       result->vars = 0;
4637     }
4638     return ((PyObject*) result);
4639   }
4640 
4641   SWIGINTERN void
4642   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
4643     swig_varlinkobject *v = (swig_varlinkobject *) p;
4644     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
4645     if (gv) {
4646       size_t size = strlen(name)+1;
4647       gv->name = (char *)malloc(size);
4648       if (gv->name) {
4649         strncpy(gv->name,name,size);
4650         gv->get_attr = get_attr;
4651         gv->set_attr = set_attr;
4652         gv->next = v->vars;
4653       }
4654     }
4655     v->vars = gv;
4656   }
4657 
4658   SWIGINTERN PyObject *
4659   SWIG_globals(void) {
4660     static PyObject *_SWIG_globals = 0;
4661     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
4662     return _SWIG_globals;
4663   }
4664 
4665   /* -----------------------------------------------------------------------------
4666    * constants/methods manipulation
4667    * ----------------------------------------------------------------------------- */
4668 
4669   /* Install Constants */
4670   SWIGINTERN void
4671   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
4672     PyObject *obj = 0;
4673     size_t i;
4674     for (i = 0; constants[i].type; ++i) {
4675       switch(constants[i].type) {
4676       case SWIG_PY_POINTER:
4677         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
4678         break;
4679       case SWIG_PY_BINARY:
4680         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
4681         break;
4682       default:
4683         obj = 0;
4684         break;
4685       }
4686       if (obj) {
4687         PyDict_SetItemString(d, constants[i].name, obj);
4688         Py_DECREF(obj);
4689       }
4690     }
4691   }
4692 
4693   /* -----------------------------------------------------------------------------*/
4694   /* Fix SwigMethods to carry the callback ptrs when needed */
4695   /* -----------------------------------------------------------------------------*/
4696 
4697   SWIGINTERN void
4698   SWIG_Python_FixMethods(PyMethodDef *methods,
4699     swig_const_info *const_table,
4700     swig_type_info **types,
4701     swig_type_info **types_initial) {
4702     size_t i;
4703     for (i = 0; methods[i].ml_name; ++i) {
4704       const char *c = methods[i].ml_doc;
4705       if (c && (c = strstr(c, "swig_ptr: "))) {
4706         int j;
4707         swig_const_info *ci = 0;
4708         const char *name = c + 10;
4709         for (j = 0; const_table[j].type; ++j) {
4710           if (strncmp(const_table[j].name, name,
4711               strlen(const_table[j].name)) == 0) {
4712             ci = &(const_table[j]);
4713             break;
4714           }
4715         }
4716         if (ci) {
4717           size_t shift = (ci->ptype) - types;
4718           swig_type_info *ty = types_initial[shift];
4719           size_t ldoc = (c - methods[i].ml_doc);
4720           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
4721           char *ndoc = (char*)malloc(ldoc + lptr + 10);
4722           if (ndoc) {
4723             char *buff = ndoc;
4724             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
4725             if (ptr) {
4726               strncpy(buff, methods[i].ml_doc, ldoc);
4727               buff += ldoc;
4728               strncpy(buff, "swig_ptr: ", 10);
4729               buff += 10;
4730               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
4731               methods[i].ml_doc = ndoc;
4732             }
4733           }
4734         }
4735       }
4736     }
4737   }
4738 
4739 #ifdef __cplusplus
4740 }
4741 #endif
4742 
4743 /* -----------------------------------------------------------------------------*
4744  *  Partial Init method
4745  * -----------------------------------------------------------------------------*/
4746 
4747 #ifdef __cplusplus
4748 extern "C"
4749 #endif
4750 SWIGEXPORT void SWIG_init(void) {
4751   PyObject *m, *d;
4752 
4753   /* Fix SwigMethods to carry the callback ptrs when needed */
4754   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
4755 
4756   m = Py_InitModule((char *) SWIG_name, SwigMethods);
4757   d = PyModule_GetDict(m);
4758 
4759   SWIG_InitializeModule(0);
4760   SWIG_InstallConstants(d,swig_const_table);
4761 
4762 
4763 }
4764 
4765