netpgpperl_wrap.c revision 1.2 
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 SWIGPERL
12#define SWIG_CASTRANK_MODE
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 * swigrun.swg
112 *
113 * This file contains generic CAPI SWIG runtime support for pointer
114 * type checking.
115 * ----------------------------------------------------------------------------- */
116
117/* This should only be incremented when either the layout of swig_type_info changes,
118   or for whatever reason, the runtime changes incompatibly */
119#define SWIG_RUNTIME_VERSION "3"
120
121/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
122#ifdef SWIG_TYPE_TABLE
123# define SWIG_QUOTE_STRING(x) #x
124# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
125# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
126#else
127# define SWIG_TYPE_TABLE_NAME
128#endif
129
130/*
131  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
132  creating a static or dynamic library from the swig runtime code.
133  In 99.9% of the cases, swig just needs to declare them as 'static'.
134
135  But only do this if is strictly necessary, ie, if you have problems
136  with your compiler or so.
137*/
138
139#ifndef SWIGRUNTIME
140# define SWIGRUNTIME SWIGINTERN
141#endif
142
143#ifndef SWIGRUNTIMEINLINE
144# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
145#endif
146
147/*  Generic buffer size */
148#ifndef SWIG_BUFFER_SIZE
149# define SWIG_BUFFER_SIZE 1024
150#endif
151
152/* Flags for pointer conversions */
153#define SWIG_POINTER_DISOWN        0x1
154
155/* Flags for new pointer objects */
156#define SWIG_POINTER_OWN           0x1
157
158
159/*
160   Flags/methods for returning states.
161
162   The swig conversion methods, as ConvertPtr, return and integer
163   that tells if the conversion was successful or not. And if not,
164   an error code can be returned (see swigerrors.swg for the codes).
165
166   Use the following macros/flags to set or process the returning
167   states.
168
169   In old swig versions, you usually write code as:
170
171     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
172       // success code
173     } else {
174       //fail code
175     }
176
177   Now you can be more explicit as:
178
179    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
180    if (SWIG_IsOK(res)) {
181      // success code
182    } else {
183      // fail code
184    }
185
186   that seems to be the same, but now you can also do
187
188    Type *ptr;
189    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
190    if (SWIG_IsOK(res)) {
191      // success code
192      if (SWIG_IsNewObj(res) {
193        ...
194	delete *ptr;
195      } else {
196        ...
197      }
198    } else {
199      // fail code
200    }
201
202   I.e., now SWIG_ConvertPtr can return new objects and you can
203   identify the case and take care of the deallocation. Of course that
204   requires also to SWIG_ConvertPtr to return new result values, as
205
206      int SWIG_ConvertPtr(obj, ptr,...) {
207        if (<obj is ok>) {
208          if (<need new object>) {
209            *ptr = <ptr to new allocated object>;
210            return SWIG_NEWOBJ;
211          } else {
212            *ptr = <ptr to old object>;
213            return SWIG_OLDOBJ;
214          }
215        } else {
216          return SWIG_BADOBJ;
217        }
218      }
219
220   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
221   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
222   swig errors code.
223
224   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
225   allows to return the 'cast rank', for example, if you have this
226
227       int food(double)
228       int fooi(int);
229
230   and you call
231
232      food(1)   // cast rank '1'  (1 -> 1.0)
233      fooi(1)   // cast rank '0'
234
235   just use the SWIG_AddCast()/SWIG_CheckState()
236
237
238 */
239#define SWIG_OK                    (0)
240#define SWIG_ERROR                 (-1)
241#define SWIG_IsOK(r)               (r >= 0)
242#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
243
244/* The CastRankLimit says how many bits are used for the cast rank */
245#define SWIG_CASTRANKLIMIT         (1 << 8)
246/* The NewMask denotes the object was created (using new/malloc) */
247#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
248/* The TmpMask is for in/out typemaps that use temporal objects */
249#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
250/* Simple returning values */
251#define SWIG_BADOBJ                (SWIG_ERROR)
252#define SWIG_OLDOBJ                (SWIG_OK)
253#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
254#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
255/* Check, add and del mask methods */
256#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
257#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
258#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
259#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
260#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
261#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
262
263
264/* Cast-Rank Mode */
265#if defined(SWIG_CASTRANK_MODE)
266#  ifndef SWIG_TypeRank
267#    define SWIG_TypeRank             unsigned long
268#  endif
269#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
270#    define SWIG_MAXCASTRANK          (2)
271#  endif
272#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
273#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
274SWIGINTERNINLINE int SWIG_AddCast(int r) {
275  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
276}
277SWIGINTERNINLINE int SWIG_CheckState(int r) {
278  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
279}
280#else /* no cast-rank mode */
281#  define SWIG_AddCast
282#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
283#endif
284
285
286
287
288#include <string.h>
289
290#ifdef __cplusplus
291extern "C" {
292#endif
293
294typedef void *(*swig_converter_func)(void *);
295typedef struct swig_type_info *(*swig_dycast_func)(void **);
296
297/* Structure to store inforomation on one type */
298typedef struct swig_type_info {
299  const char             *name;			/* mangled name of this type */
300  const char             *str;			/* human readable name of this type */
301  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
302  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
303  void                   *clientdata;		/* language specific type data */
304  int                    owndata;		/* flag if the structure owns the clientdata */
305} swig_type_info;
306
307/* Structure to store a type and conversion function used for casting */
308typedef struct swig_cast_info {
309  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
310  swig_converter_func     converter;		/* function to cast the void pointers */
311  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
312  struct swig_cast_info  *prev;			/* pointer to the previous cast */
313} swig_cast_info;
314
315/* Structure used to store module information
316 * Each module generates one structure like this, and the runtime collects
317 * all of these structures and stores them in a circularly linked list.*/
318typedef struct swig_module_info {
319  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
320  size_t                 size;		        /* Number of types in this module */
321  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
322  swig_type_info         **type_initial;	/* Array of initially generated type structures */
323  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
324  void                    *clientdata;		/* Language specific module data */
325} swig_module_info;
326
327/*
328  Compare two type names skipping the space characters, therefore
329  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
330
331  Return 0 when the two name types are equivalent, as in
332  strncmp, but skipping ' '.
333*/
334SWIGRUNTIME int
335SWIG_TypeNameComp(const char *f1, const char *l1,
336		  const char *f2, const char *l2) {
337  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
338    while ((*f1 == ' ') && (f1 != l1)) ++f1;
339    while ((*f2 == ' ') && (f2 != l2)) ++f2;
340    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
341  }
342  return (l1 - f1) - (l2 - f2);
343}
344
345/*
346  Check type equivalence in a name list like <name1>|<name2>|...
347  Return 0 if not equal, 1 if equal
348*/
349SWIGRUNTIME int
350SWIG_TypeEquiv(const char *nb, const char *tb) {
351  int equiv = 0;
352  const char* te = tb + strlen(tb);
353  const char* ne = nb;
354  while (!equiv && *ne) {
355    for (nb = ne; *ne; ++ne) {
356      if (*ne == '|') break;
357    }
358    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
359    if (*ne) ++ne;
360  }
361  return equiv;
362}
363
364/*
365  Check type equivalence in a name list like <name1>|<name2>|...
366  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
367*/
368SWIGRUNTIME int
369SWIG_TypeCompare(const char *nb, const char *tb) {
370  int equiv = 0;
371  const char* te = tb + strlen(tb);
372  const char* ne = nb;
373  while (!equiv && *ne) {
374    for (nb = ne; *ne; ++ne) {
375      if (*ne == '|') break;
376    }
377    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
378    if (*ne) ++ne;
379  }
380  return equiv;
381}
382
383
384/* think of this as a c++ template<> or a scheme macro */
385#define SWIG_TypeCheck_Template(comparison, ty)         \
386  if (ty) {                                             \
387    swig_cast_info *iter = ty->cast;                    \
388    while (iter) {                                      \
389      if (comparison) {                                 \
390        if (iter == ty->cast) return iter;              \
391        /* Move iter to the top of the linked list */   \
392        iter->prev->next = iter->next;                  \
393        if (iter->next)                                 \
394          iter->next->prev = iter->prev;                \
395        iter->next = ty->cast;                          \
396        iter->prev = 0;                                 \
397        if (ty->cast) ty->cast->prev = iter;            \
398        ty->cast = iter;                                \
399        return iter;                                    \
400      }                                                 \
401      iter = iter->next;                                \
402    }                                                   \
403  }                                                     \
404  return 0
405
406/*
407  Check the typename
408*/
409SWIGRUNTIME swig_cast_info *
410SWIG_TypeCheck(const char *c, swig_type_info *ty) {
411  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
412}
413
414/* Same as previous function, except strcmp is replaced with a pointer comparison */
415SWIGRUNTIME swig_cast_info *
416SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
417  SWIG_TypeCheck_Template(iter->type == from, into);
418}
419
420/*
421  Cast a pointer up an inheritance hierarchy
422*/
423SWIGRUNTIMEINLINE void *
424SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
425  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
426}
427
428/*
429   Dynamic pointer casting. Down an inheritance hierarchy
430*/
431SWIGRUNTIME swig_type_info *
432SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
433  swig_type_info *lastty = ty;
434  if (!ty || !ty->dcast) return ty;
435  while (ty && (ty->dcast)) {
436    ty = (*ty->dcast)(ptr);
437    if (ty) lastty = ty;
438  }
439  return lastty;
440}
441
442/*
443  Return the name associated with this type
444*/
445SWIGRUNTIMEINLINE const char *
446SWIG_TypeName(const swig_type_info *ty) {
447  return ty->name;
448}
449
450/*
451  Return the pretty name associated with this type,
452  that is an unmangled type name in a form presentable to the user.
453*/
454SWIGRUNTIME const char *
455SWIG_TypePrettyName(const swig_type_info *type) {
456  /* The "str" field contains the equivalent pretty names of the
457     type, separated by vertical-bar characters.  We choose
458     to print the last name, as it is often (?) the most
459     specific. */
460  if (!type) return NULL;
461  if (type->str != NULL) {
462    const char *last_name = type->str;
463    const char *s;
464    for (s = type->str; *s; s++)
465      if (*s == '|') last_name = s+1;
466    return last_name;
467  }
468  else
469    return type->name;
470}
471
472/*
473   Set the clientdata field for a type
474*/
475SWIGRUNTIME void
476SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
477  swig_cast_info *cast = ti->cast;
478  /* if (ti->clientdata == clientdata) return; */
479  ti->clientdata = clientdata;
480
481  while (cast) {
482    if (!cast->converter) {
483      swig_type_info *tc = cast->type;
484      if (!tc->clientdata) {
485	SWIG_TypeClientData(tc, clientdata);
486      }
487    }
488    cast = cast->next;
489  }
490}
491SWIGRUNTIME void
492SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
493  SWIG_TypeClientData(ti, clientdata);
494  ti->owndata = 1;
495}
496
497/*
498  Search for a swig_type_info structure only by mangled name
499  Search is a O(log #types)
500
501  We start searching at module start, and finish searching when start == end.
502  Note: if start == end at the beginning of the function, we go all the way around
503  the circular list.
504*/
505SWIGRUNTIME swig_type_info *
506SWIG_MangledTypeQueryModule(swig_module_info *start,
507                            swig_module_info *end,
508		            const char *name) {
509  swig_module_info *iter = start;
510  do {
511    if (iter->size) {
512      register size_t l = 0;
513      register size_t r = iter->size - 1;
514      do {
515	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
516	register size_t i = (l + r) >> 1;
517	const char *iname = iter->types[i]->name;
518	if (iname) {
519	  register int compare = strcmp(name, iname);
520	  if (compare == 0) {
521	    return iter->types[i];
522	  } else if (compare < 0) {
523	    if (i) {
524	      r = i - 1;
525	    } else {
526	      break;
527	    }
528	  } else if (compare > 0) {
529	    l = i + 1;
530	  }
531	} else {
532	  break; /* should never happen */
533	}
534      } while (l <= r);
535    }
536    iter = iter->next;
537  } while (iter != end);
538  return 0;
539}
540
541/*
542  Search for a swig_type_info structure for either a mangled name or a human readable name.
543  It first searches the mangled names of the types, which is a O(log #types)
544  If a type is not found it then searches the human readable names, which is O(#types).
545
546  We start searching at module start, and finish searching when start == end.
547  Note: if start == end at the beginning of the function, we go all the way around
548  the circular list.
549*/
550SWIGRUNTIME swig_type_info *
551SWIG_TypeQueryModule(swig_module_info *start,
552                     swig_module_info *end,
553		     const char *name) {
554  /* STEP 1: Search the name field using binary search */
555  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
556  if (ret) {
557    return ret;
558  } else {
559    /* STEP 2: If the type hasn't been found, do a complete search
560       of the str field (the human readable name) */
561    swig_module_info *iter = start;
562    do {
563      register size_t i = 0;
564      for (; i < iter->size; ++i) {
565	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
566	  return iter->types[i];
567      }
568      iter = iter->next;
569    } while (iter != end);
570  }
571
572  /* neither found a match */
573  return 0;
574}
575
576/*
577   Pack binary data into a string
578*/
579SWIGRUNTIME char *
580SWIG_PackData(char *c, void *ptr, size_t sz) {
581  static const char hex[17] = "0123456789abcdef";
582  register const unsigned char *u = (unsigned char *) ptr;
583  register const unsigned char *eu =  u + sz;
584  for (; u != eu; ++u) {
585    register unsigned char uu = *u;
586    *(c++) = hex[(uu & 0xf0) >> 4];
587    *(c++) = hex[uu & 0xf];
588  }
589  return c;
590}
591
592/*
593   Unpack binary data from a string
594*/
595SWIGRUNTIME const char *
596SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
597  register unsigned char *u = (unsigned char *) ptr;
598  register const unsigned char *eu = u + sz;
599  for (; u != eu; ++u) {
600    register char d = *(c++);
601    register unsigned char uu;
602    if ((d >= '0') && (d <= '9'))
603      uu = ((d - '0') << 4);
604    else if ((d >= 'a') && (d <= 'f'))
605      uu = ((d - ('a'-10)) << 4);
606    else
607      return (char *) 0;
608    d = *(c++);
609    if ((d >= '0') && (d <= '9'))
610      uu |= (d - '0');
611    else if ((d >= 'a') && (d <= 'f'))
612      uu |= (d - ('a'-10));
613    else
614      return (char *) 0;
615    *u = uu;
616  }
617  return c;
618}
619
620/*
621   Pack 'void *' into a string buffer.
622*/
623SWIGRUNTIME char *
624SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
625  char *r = buff;
626  if ((2*sizeof(void *) + 2) > bsz) return 0;
627  *(r++) = '_';
628  r = SWIG_PackData(r,&ptr,sizeof(void *));
629  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
630  strcpy(r,name);
631  return buff;
632}
633
634SWIGRUNTIME const char *
635SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
636  if (*c != '_') {
637    if (strcmp(c,"NULL") == 0) {
638      *ptr = (void *) 0;
639      return name;
640    } else {
641      return 0;
642    }
643  }
644  return SWIG_UnpackData(++c,ptr,sizeof(void *));
645}
646
647SWIGRUNTIME char *
648SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
649  char *r = buff;
650  size_t lname = (name ? strlen(name) : 0);
651  if ((2*sz + 2 + lname) > bsz) return 0;
652  *(r++) = '_';
653  r = SWIG_PackData(r,ptr,sz);
654  if (lname) {
655    strncpy(r,name,lname+1);
656  } else {
657    *r = 0;
658  }
659  return buff;
660}
661
662SWIGRUNTIME const char *
663SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
664  if (*c != '_') {
665    if (strcmp(c,"NULL") == 0) {
666      memset(ptr,0,sz);
667      return name;
668    } else {
669      return 0;
670    }
671  }
672  return SWIG_UnpackData(++c,ptr,sz);
673}
674
675#ifdef __cplusplus
676}
677#endif
678
679/*  Errors in SWIG */
680#define  SWIG_UnknownError    	   -1
681#define  SWIG_IOError        	   -2
682#define  SWIG_RuntimeError   	   -3
683#define  SWIG_IndexError     	   -4
684#define  SWIG_TypeError      	   -5
685#define  SWIG_DivisionByZero 	   -6
686#define  SWIG_OverflowError  	   -7
687#define  SWIG_SyntaxError    	   -8
688#define  SWIG_ValueError     	   -9
689#define  SWIG_SystemError    	   -10
690#define  SWIG_AttributeError 	   -11
691#define  SWIG_MemoryError    	   -12
692#define  SWIG_NullReferenceError   -13
693
694
695
696#ifdef __cplusplus
697/* Needed on some windows machines---since MS plays funny games with the header files under C++ */
698#include <math.h>
699#include <stdlib.h>
700extern "C" {
701#endif
702#include "EXTERN.h"
703#include "perl.h"
704#include "XSUB.h"
705
706/* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
707
708/* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
709#ifndef PERL_REVISION
710#  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
711#    define PERL_PATCHLEVEL_H_IMPLICIT
712#    include <patchlevel.h>
713#  endif
714#  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
715#    include <could_not_find_Perl_patchlevel.h>
716#  endif
717#  ifndef PERL_REVISION
718#    define PERL_REVISION       (5)
719#    define PERL_VERSION        PATCHLEVEL
720#    define PERL_SUBVERSION     SUBVERSION
721#  endif
722#endif
723
724#if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
725#define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
726#endif
727
728#ifndef SvIOK_UV
729# define SvIOK_UV(sv)       (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
730#endif
731
732#ifndef SvUOK
733# define SvUOK(sv)           SvIOK_UV(sv)
734#endif
735
736#if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
737#  define PL_sv_undef               sv_undef
738#  define PL_na	                    na
739#  define PL_errgv                  errgv
740#  define PL_sv_no                  sv_no
741#  define PL_sv_yes                 sv_yes
742#  define PL_markstack_ptr          markstack_ptr
743#endif
744
745#ifndef IVSIZE
746#  ifdef LONGSIZE
747#    define IVSIZE LONGSIZE
748#  else
749#    define IVSIZE 4 /* A bold guess, but the best we can make. */
750#  endif
751#endif
752
753#ifndef INT2PTR
754#  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
755#    define PTRV                  UV
756#    define INT2PTR(any,d)        (any)(d)
757#  else
758#    if PTRSIZE == LONGSIZE
759#      define PTRV                unsigned long
760#    else
761#      define PTRV                unsigned
762#    endif
763#    define INT2PTR(any,d)        (any)(PTRV)(d)
764#  endif
765
766#  define NUM2PTR(any,d)  (any)(PTRV)(d)
767#  define PTR2IV(p)       INT2PTR(IV,p)
768#  define PTR2UV(p)       INT2PTR(UV,p)
769#  define PTR2NV(p)       NUM2PTR(NV,p)
770
771#  if PTRSIZE == LONGSIZE
772#    define PTR2ul(p)     (unsigned long)(p)
773#  else
774#    define PTR2ul(p)     INT2PTR(unsigned long,p)
775#  endif
776#endif /* !INT2PTR */
777
778#ifndef get_sv
779#  define get_sv perl_get_sv
780#endif
781
782#ifndef ERRSV
783#  define ERRSV get_sv("@",FALSE)
784#endif
785
786#ifndef pTHX_
787#define pTHX_
788#endif
789
790#include <string.h>
791#ifdef __cplusplus
792}
793#endif
794
795/* -----------------------------------------------------------------------------
796 * error manipulation
797 * ----------------------------------------------------------------------------- */
798
799SWIGINTERN const char*
800SWIG_Perl_ErrorType(int code) {
801  const char* type = 0;
802  switch(code) {
803  case SWIG_MemoryError:
804    type = "MemoryError";
805    break;
806  case SWIG_IOError:
807    type = "IOError";
808    break;
809  case SWIG_RuntimeError:
810    type = "RuntimeError";
811    break;
812  case SWIG_IndexError:
813    type = "IndexError";
814    break;
815  case SWIG_TypeError:
816    type = "TypeError";
817    break;
818  case SWIG_DivisionByZero:
819    type = "ZeroDivisionError";
820    break;
821  case SWIG_OverflowError:
822    type = "OverflowError";
823    break;
824  case SWIG_SyntaxError:
825    type = "SyntaxError";
826    break;
827  case SWIG_ValueError:
828    type = "ValueError";
829    break;
830  case SWIG_SystemError:
831    type = "SystemError";
832    break;
833  case SWIG_AttributeError:
834    type = "AttributeError";
835    break;
836  default:
837    type = "RuntimeError";
838  }
839  return type;
840}
841
842
843
844
845/* -----------------------------------------------------------------------------
846 * perlrun.swg
847 *
848 * This file contains the runtime support for Perl modules
849 * and includes code for managing global variables and pointer
850 * type checking.
851 * ----------------------------------------------------------------------------- */
852
853#ifdef PERL_OBJECT
854#define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
855#define SWIG_PERL_OBJECT_CALL pPerl,
856#else
857#define SWIG_PERL_OBJECT_DECL
858#define SWIG_PERL_OBJECT_CALL
859#endif
860
861/* Common SWIG API */
862
863/* for raw pointers */
864#define SWIG_ConvertPtr(obj, pp, type, flags)           SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
865#define SWIG_NewPointerObj(p, type, flags)              SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
866
867/* for raw packed data */
868#define SWIG_ConvertPacked(obj, p, s, type)             SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
869#define SWIG_NewPackedObj(p, s, type)	                SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
870
871/* for class or struct pointers */
872#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
873#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
874
875/* for C or C++ function pointers */
876#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
877#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
878
879/* for C++ member pointers, ie, member methods */
880#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_ConvertPacked(obj, ptr, sz, ty)
881#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_NewPackedObj(ptr, sz, type)
882
883
884/* Runtime API */
885
886#define SWIG_GetModule(clientdata)                      SWIG_Perl_GetModule()
887#define SWIG_SetModule(clientdata, pointer)             SWIG_Perl_SetModule(pointer)
888
889
890/* Error manipulation */
891
892#define SWIG_ErrorType(code)                            SWIG_Perl_ErrorType(code)
893#define SWIG_Error(code, msg)            		sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg)
894#define SWIG_fail                        		goto fail
895
896/* Perl-specific SWIG API */
897
898#define SWIG_MakePtr(sv, ptr, type, flags)              SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
899#define SWIG_MakePackedObj(sv, p, s, type)	        SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
900#define SWIG_SetError(str)                              SWIG_Error(SWIG_RuntimeError, str)
901
902
903#define SWIG_PERL_DECL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_DECL arg1)
904#define SWIG_PERL_CALL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_CALL arg1)
905#define SWIG_PERL_DECL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_DECL arg1, arg2)
906#define SWIG_PERL_CALL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_CALL arg1, arg2)
907
908/* -----------------------------------------------------------------------------
909 * pointers/data manipulation
910 * ----------------------------------------------------------------------------- */
911
912/* For backward compatibility only */
913#define SWIG_POINTER_EXCEPTION  0
914
915#ifdef __cplusplus
916extern "C" {
917#endif
918
919#define SWIG_OWNER   SWIG_POINTER_OWN
920#define SWIG_SHADOW  SWIG_OWNER << 1
921
922#define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
923
924/* SWIG Perl macros */
925
926/* Macro to call an XS function */
927#ifdef PERL_OBJECT
928#  define SWIG_CALLXS(_name) _name(cv,pPerl)
929#else
930#  ifndef MULTIPLICITY
931#    define SWIG_CALLXS(_name) _name(cv)
932#  else
933#    define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
934#  endif
935#endif
936
937/* Note: SwigMagicFuncHack is a typedef used to get the C++ compiler to just shut up already */
938
939#ifdef PERL_OBJECT
940#define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
941typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
942
943#ifdef __cplusplus
944extern "C" {
945#endif
946typedef int (CPerlObj::*SwigMagicFuncHack)(SV *, MAGIC *);
947#ifdef __cplusplus
948}
949#endif
950
951#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
952#define SWIGCLASS_STATIC
953#else
954#define MAGIC_PPERL
955#define SWIGCLASS_STATIC static SWIGUNUSED
956#ifndef MULTIPLICITY
957#define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
958typedef int (*SwigMagicFunc)(SV *, MAGIC *);
959
960#ifdef __cplusplus
961extern "C" {
962#endif
963typedef int (*SwigMagicFuncHack)(SV *, MAGIC *);
964#ifdef __cplusplus
965}
966#endif
967
968
969#else
970#define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
971typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
972#ifdef __cplusplus
973extern "C" {
974#endif
975typedef int (*SwigMagicFuncHack)(struct interpreter *, SV *, MAGIC *);
976#ifdef __cplusplus
977}
978#endif
979
980#endif
981#endif
982
983/* Workaround for bug in perl 5.6.x croak and earlier */
984#if (PERL_VERSION < 8)
985#  ifdef PERL_OBJECT
986#    define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
987static void SWIG_Perl_croak_null(CPerlObj *pPerl)
988#  else
989static void SWIG_croak_null()
990#  endif
991{
992  SV *err=ERRSV;
993#  if (PERL_VERSION < 6)
994  croak("%_", err);
995#  else
996  if (SvOK(err) && !SvROK(err)) croak("%_", err);
997  croak(Nullch);
998#  endif
999}
1000#else
1001#  define SWIG_croak_null() croak(Nullch)
1002#endif
1003
1004
1005/*
1006   Define how strict is the cast between strings and integers/doubles
1007   when overloading between these types occurs.
1008
1009   The default is making it as strict as possible by using SWIG_AddCast
1010   when needed.
1011
1012   You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
1013   disable the SWIG_AddCast, making the casting between string and
1014   numbers less strict.
1015
1016   In the end, we try to solve the overloading between strings and
1017   numerical types in the more natural way, but if you can avoid it,
1018   well, avoid it using %rename, for example.
1019*/
1020#ifndef SWIG_PERL_NO_STRICT_STR2NUM
1021# ifndef SWIG_PERL_STRICT_STR2NUM
1022#  define SWIG_PERL_STRICT_STR2NUM
1023# endif
1024#endif
1025#ifdef SWIG_PERL_STRICT_STR2NUM
1026/* string takes precedence */
1027#define SWIG_Str2NumCast(x) SWIG_AddCast(x)
1028#else
1029/* number takes precedence */
1030#define SWIG_Str2NumCast(x) x
1031#endif
1032
1033
1034
1035#include <stdlib.h>
1036
1037SWIGRUNTIME const char *
1038SWIG_Perl_TypeProxyName(const swig_type_info *type) {
1039  if (!type) return NULL;
1040  if (type->clientdata != NULL) {
1041    return (const char*) type->clientdata;
1042  }
1043  else {
1044    return type->name;
1045  }
1046}
1047
1048SWIGRUNTIME swig_cast_info *
1049SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
1050  SWIG_TypeCheck_Template(( (!iter->type->clientdata && (strcmp((char*)iter->type->name, c) == 0))
1051			    || (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0))), ty);
1052}
1053
1054
1055/* Function for getting a pointer value */
1056
1057SWIGRUNTIME int
1058SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
1059  swig_cast_info *tc;
1060  void *voidptr = (void *)0;
1061  SV *tsv = 0;
1062  /* If magical, apply more magic */
1063  if (SvGMAGICAL(sv))
1064    mg_get(sv);
1065
1066  /* Check to see if this is an object */
1067  if (sv_isobject(sv)) {
1068    IV tmp = 0;
1069    tsv = (SV*) SvRV(sv);
1070    if ((SvTYPE(tsv) == SVt_PVHV)) {
1071      MAGIC *mg;
1072      if (SvMAGICAL(tsv)) {
1073        mg = mg_find(tsv,'P');
1074        if (mg) {
1075          sv = mg->mg_obj;
1076          if (sv_isobject(sv)) {
1077	    tsv = (SV*)SvRV(sv);
1078            tmp = SvIV(tsv);
1079          }
1080        }
1081      } else {
1082        return SWIG_ERROR;
1083      }
1084    } else {
1085      tmp = SvIV(tsv);
1086    }
1087    voidptr = INT2PTR(void *,tmp);
1088  } else if (! SvOK(sv)) {            /* Check for undef */
1089    *(ptr) = (void *) 0;
1090    return SWIG_OK;
1091  } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
1092    if (!SvROK(sv)) {
1093      *(ptr) = (void *) 0;
1094      return SWIG_OK;
1095    } else {
1096      return SWIG_ERROR;
1097    }
1098  } else {                            /* Don't know what it is */
1099    return SWIG_ERROR;
1100  }
1101  if (_t) {
1102    /* Now see if the types match */
1103    char *_c = HvNAME(SvSTASH(SvRV(sv)));
1104    tc = SWIG_TypeProxyCheck(_c,_t);
1105    if (!tc) {
1106      return SWIG_ERROR;
1107    }
1108    *ptr = SWIG_TypeCast(tc,voidptr);
1109  } else {
1110    *ptr = voidptr;
1111  }
1112
1113  /*
1114   *  DISOWN implementation: we need a perl guru to check this one.
1115   */
1116  if (tsv && (flags & SWIG_POINTER_DISOWN)) {
1117    /*
1118     *  almost copy paste code from below SWIG_POINTER_OWN setting
1119     */
1120    SV *obj = sv;
1121    HV *stash = SvSTASH(SvRV(obj));
1122    GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
1123    if (isGV(gv)) {
1124      HV *hv = GvHVn(gv);
1125      /*
1126       * To set ownership (see below), a newSViv(1) entry is added.
1127       * Hence, to remove ownership, we delete the entry.
1128       */
1129      if (hv_exists_ent(hv, obj, 0)) {
1130	hv_delete_ent(hv, obj, 0, 0);
1131      }
1132    }
1133  }
1134  return SWIG_OK;
1135}
1136
1137SWIGRUNTIME void
1138SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
1139  if (ptr && (flags & SWIG_SHADOW)) {
1140    SV *self;
1141    SV *obj=newSV(0);
1142    HV *hash=newHV();
1143    HV *stash;
1144    sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1145    stash=SvSTASH(SvRV(obj));
1146    if (flags & SWIG_POINTER_OWN) {
1147      HV *hv;
1148      GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1149      if (!isGV(gv))
1150        gv_init(gv, stash, "OWNER", 5, FALSE);
1151      hv=GvHVn(gv);
1152      hv_store_ent(hv, obj, newSViv(1), 0);
1153    }
1154    sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
1155    SvREFCNT_dec(obj);
1156    self=newRV_noinc((SV *)hash);
1157    sv_setsv(sv, self);
1158    SvREFCNT_dec((SV *)self);
1159    sv_bless(sv, stash);
1160  }
1161  else {
1162    sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1163  }
1164}
1165
1166SWIGRUNTIMEINLINE SV *
1167SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
1168  SV *result = sv_newmortal();
1169  SWIG_MakePtr(result, ptr, t, flags);
1170  return result;
1171}
1172
1173SWIGRUNTIME void
1174SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
1175  char result[1024];
1176  char *r = result;
1177  if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
1178  *(r++) = '_';
1179  r = SWIG_PackData(r,ptr,sz);
1180  strcpy(r,SWIG_Perl_TypeProxyName(type));
1181  sv_setpv(sv, result);
1182}
1183
1184SWIGRUNTIME SV *
1185SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
1186  SV *result = sv_newmortal();
1187  SWIG_Perl_MakePackedObj(result, ptr, sz, type);
1188  return result;
1189}
1190
1191/* Convert a packed value value */
1192SWIGRUNTIME int
1193SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
1194  swig_cast_info *tc;
1195  const char  *c = 0;
1196
1197  if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
1198  c = SvPV(obj, PL_na);
1199  /* Pointer values must start with leading underscore */
1200  if (*c != '_') return SWIG_ERROR;
1201  c++;
1202  c = SWIG_UnpackData(c,ptr,sz);
1203  if (ty) {
1204    tc = SWIG_TypeCheck(c,ty);
1205    if (!tc) return SWIG_ERROR;
1206  }
1207  return SWIG_OK;
1208}
1209
1210
1211/* Macros for low-level exception handling */
1212#define SWIG_croak(x)    { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
1213
1214
1215typedef XS(SwigPerlWrapper);
1216typedef SwigPerlWrapper *SwigPerlWrapperPtr;
1217
1218/* Structure for command table */
1219typedef struct {
1220  const char         *name;
1221  SwigPerlWrapperPtr  wrapper;
1222} swig_command_info;
1223
1224/* Information for constant table */
1225
1226#define SWIG_INT     1
1227#define SWIG_FLOAT   2
1228#define SWIG_STRING  3
1229#define SWIG_POINTER 4
1230#define SWIG_BINARY  5
1231
1232/* Constant information structure */
1233typedef struct swig_constant_info {
1234    int              type;
1235    const char      *name;
1236    long             lvalue;
1237    double           dvalue;
1238    void            *pvalue;
1239    swig_type_info **ptype;
1240} swig_constant_info;
1241
1242
1243/* Structure for variable table */
1244typedef struct {
1245  const char   *name;
1246  SwigMagicFunc   set;
1247  SwigMagicFunc   get;
1248  swig_type_info  **type;
1249} swig_variable_info;
1250
1251/* Magic variable code */
1252#ifndef PERL_OBJECT
1253#define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
1254  #ifndef MULTIPLICITY
1255     SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
1256  #else
1257     SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
1258  #endif
1259#else
1260#  define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
1261SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
1262#endif
1263{
1264  MAGIC *mg;
1265  sv_magic(sv,sv,'U',(char *) name,strlen(name));
1266  mg = mg_find(sv,'U');
1267  mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
1268  mg->mg_virtual->svt_get = (SwigMagicFuncHack) get;
1269  mg->mg_virtual->svt_set = (SwigMagicFuncHack) set;
1270  mg->mg_virtual->svt_len = 0;
1271  mg->mg_virtual->svt_clear = 0;
1272  mg->mg_virtual->svt_free = 0;
1273}
1274
1275
1276SWIGRUNTIME swig_module_info *
1277SWIG_Perl_GetModule(void) {
1278  static void *type_pointer = (void *)0;
1279  SV *pointer;
1280
1281  /* first check if pointer already created */
1282  if (!type_pointer) {
1283    pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE);
1284    if (pointer && SvOK(pointer)) {
1285      type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
1286    }
1287  }
1288
1289  return (swig_module_info *) type_pointer;
1290}
1291
1292SWIGRUNTIME void
1293SWIG_Perl_SetModule(swig_module_info *module) {
1294  SV *pointer;
1295
1296  /* create a new pointer */
1297  pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE);
1298  sv_setiv(pointer, PTR2IV(module));
1299}
1300
1301#ifdef __cplusplus
1302}
1303#endif
1304
1305/* Workaround perl5 global namespace pollution. Note that undefining library
1306 * functions like fopen will not solve the problem on all platforms as fopen
1307 * might be a macro on Windows but not necessarily on other operating systems. */
1308#ifdef do_open
1309  #undef do_open
1310#endif
1311#ifdef do_close
1312  #undef do_close
1313#endif
1314#ifdef scalar
1315  #undef scalar
1316#endif
1317#ifdef list
1318  #undef list
1319#endif
1320#ifdef apply
1321  #undef apply
1322#endif
1323#ifdef convert
1324  #undef convert
1325#endif
1326#ifdef Error
1327  #undef Error
1328#endif
1329#ifdef form
1330  #undef form
1331#endif
1332#ifdef vform
1333  #undef vform
1334#endif
1335#ifdef LABEL
1336  #undef LABEL
1337#endif
1338#ifdef METHOD
1339  #undef METHOD
1340#endif
1341#ifdef Move
1342  #undef Move
1343#endif
1344#ifdef yylex
1345  #undef yylex
1346#endif
1347#ifdef yyparse
1348  #undef yyparse
1349#endif
1350#ifdef yyerror
1351  #undef yyerror
1352#endif
1353#ifdef invert
1354  #undef invert
1355#endif
1356#ifdef ref
1357  #undef ref
1358#endif
1359#ifdef read
1360  #undef read
1361#endif
1362#ifdef write
1363  #undef write
1364#endif
1365#ifdef eof
1366  #undef eof
1367#endif
1368#ifdef bool
1369  #undef bool
1370#endif
1371#ifdef close
1372  #undef close
1373#endif
1374#ifdef rewind
1375  #undef rewind
1376#endif
1377#ifdef free
1378  #undef free
1379#endif
1380#ifdef malloc
1381  #undef malloc
1382#endif
1383#ifdef calloc
1384  #undef calloc
1385#endif
1386#ifdef Stat
1387  #undef Stat
1388#endif
1389#ifdef check
1390  #undef check
1391#endif
1392#ifdef seekdir
1393  #undef seekdir
1394#endif
1395#ifdef open
1396  #undef open
1397#endif
1398
1399
1400
1401#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1402
1403#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1404
1405
1406
1407/* -------- TYPES TABLE (BEGIN) -------- */
1408
1409#define SWIGTYPE_p_char swig_types[0]
1410#define SWIGTYPE_p_netpgp_t swig_types[1]
1411#define SWIGTYPE_p_p_char swig_types[2]
1412#define SWIGTYPE_p_void swig_types[3]
1413static swig_type_info *swig_types[5];
1414static swig_module_info swig_module = {swig_types, 4, 0, 0, 0, 0};
1415#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1416#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1417
1418/* -------- TYPES TABLE (END) -------- */
1419
1420#define SWIG_init    boot_netpgpperl
1421
1422#define SWIG_name   "netpgpperlc::boot_netpgpperl"
1423#define SWIG_prefix "netpgpperlc::"
1424
1425#define SWIGVERSION 0x010331
1426#define SWIG_VERSION SWIGVERSION
1427
1428
1429#define SWIG_as_voidptr(a) (void *)((const void *)(a))
1430#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1431
1432
1433#ifdef __cplusplus
1434extern "C"
1435#endif
1436#ifndef PERL_OBJECT
1437#ifndef MULTIPLICITY
1438SWIGEXPORT void SWIG_init (CV* cv);
1439#else
1440SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1441#endif
1442#else
1443SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1444#endif
1445
1446
1447#include <netpgp.h>
1448#undef SvPOK
1449#define SvPOK(x) 1
1450
1451
1452#include <limits.h>
1453#ifndef LLONG_MIN
1454# define LLONG_MIN	LONG_LONG_MIN
1455#endif
1456#ifndef LLONG_MAX
1457# define LLONG_MAX	LONG_LONG_MAX
1458#endif
1459#ifndef ULLONG_MAX
1460# define ULLONG_MAX	ULONG_LONG_MAX
1461#endif
1462
1463
1464SWIGINTERN int
1465SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1466{
1467  if (SvNIOK(obj)) {
1468    if (val) *val = SvNV(obj);
1469    return SWIG_OK;
1470  } else if (SvIOK(obj)) {
1471    if (val) *val = (double) SvIV(obj);
1472    return SWIG_AddCast(SWIG_OK);
1473  } else {
1474    const char *nptr = SvPV(obj, PL_na);
1475    if (nptr) {
1476      char *endptr;
1477      double v = strtod(nptr, &endptr);
1478      if (errno == ERANGE) {
1479	errno = 0;
1480	return SWIG_OverflowError;
1481      } else {
1482	if (*endptr == '\0') {
1483	  if (val) *val = v;
1484	  return SWIG_Str2NumCast(SWIG_OK);
1485	}
1486      }
1487    }
1488  }
1489  return SWIG_TypeError;
1490}
1491
1492
1493#include <float.h>
1494
1495
1496#include <math.h>
1497
1498
1499SWIGINTERNINLINE int
1500SWIG_CanCastAsInteger(double *d, double min, double max) {
1501  double x = *d;
1502  if ((min <= x && x <= max)) {
1503   double fx = floor(x);
1504   double cx = ceil(x);
1505   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1506   if ((errno == EDOM) || (errno == ERANGE)) {
1507     errno = 0;
1508   } else {
1509     double summ, reps, diff;
1510     if (rd < x) {
1511       diff = x - rd;
1512     } else if (rd > x) {
1513       diff = rd - x;
1514     } else {
1515       return 1;
1516     }
1517     summ = rd + x;
1518     reps = diff/summ;
1519     if (reps < 8*DBL_EPSILON) {
1520       *d = rd;
1521       return 1;
1522     }
1523   }
1524  }
1525  return 0;
1526}
1527
1528
1529SWIGINTERN int
1530SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
1531{
1532  if (SvUOK(obj)) {
1533    if (val) *val = SvUV(obj);
1534    return SWIG_OK;
1535  } else  if (SvIOK(obj)) {
1536    long v = SvIV(obj);
1537    if (v >= 0) {
1538      if (val) *val = v;
1539      return SWIG_OK;
1540    } else {
1541      return SWIG_OverflowError;
1542    }
1543  } else {
1544    int dispatch = 0;
1545    const char *nptr = SvPV(obj, PL_na);
1546    if (nptr) {
1547      char *endptr;
1548      unsigned long v = strtoul(nptr, &endptr,0);
1549      if (errno == ERANGE) {
1550	errno = 0;
1551	return SWIG_OverflowError;
1552      } else {
1553	if (*endptr == '\0') {
1554	  if (val) *val = v;
1555	  return SWIG_Str2NumCast(SWIG_OK);
1556	}
1557      }
1558    }
1559    if (!dispatch) {
1560      double d;
1561      int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1562      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
1563	if (val) *val = (unsigned long)(d);
1564	return res;
1565      }
1566    }
1567  }
1568  return SWIG_TypeError;
1569}
1570
1571
1572SWIGINTERN int
1573SWIG_AsVal_unsigned_SS_int SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned int *val)
1574{
1575  unsigned long v;
1576  int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1577  if (SWIG_IsOK(res)) {
1578    if ((v > UINT_MAX)) {
1579      return SWIG_OverflowError;
1580    } else {
1581      if (val) *val = (unsigned int)(v);
1582    }
1583  }
1584  return res;
1585}
1586
1587
1588SWIGINTERNINLINE SV *
1589SWIG_From_unsigned_SS_long  SWIG_PERL_DECL_ARGS_1(unsigned long value)
1590{
1591  SV *obj = sv_newmortal();
1592  sv_setuv(obj, (UV) value);
1593  return obj;
1594}
1595
1596
1597SWIGINTERNINLINE SV *
1598SWIG_From_unsigned_SS_int  SWIG_PERL_DECL_ARGS_1(unsigned int value)
1599{
1600  return SWIG_From_unsigned_SS_long  SWIG_PERL_CALL_ARGS_1(value);
1601}
1602
1603
1604SWIGINTERNINLINE SV *
1605SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
1606{
1607  SV *obj = sv_newmortal();
1608  sv_setiv(obj, (IV) value);
1609  return obj;
1610}
1611
1612
1613SWIGINTERNINLINE SV *
1614SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
1615{
1616  return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
1617}
1618
1619
1620SWIGINTERN swig_type_info*
1621SWIG_pchar_descriptor(void)
1622{
1623  static int init = 0;
1624  static swig_type_info* info = 0;
1625  if (!init) {
1626    info = SWIG_TypeQuery("_p_char");
1627    init = 1;
1628  }
1629  return info;
1630}
1631
1632
1633SWIGINTERN int
1634SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1635{
1636  if (SvPOK(obj)) {
1637    STRLEN len = 0;
1638    char *cstr = SvPV(obj, len);
1639    size_t size = len + 1;
1640    if (cptr)  {
1641      if (alloc) {
1642	if (*alloc == SWIG_NEWOBJ) {
1643	  *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1644	} else {
1645	  *cptr = cstr;
1646	  *alloc = SWIG_OLDOBJ;
1647	}
1648      }
1649    }
1650    if (psize) *psize = size;
1651    return SWIG_OK;
1652  } else {
1653    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1654    if (pchar_descriptor) {
1655      char* vptr = 0;
1656      if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1657	if (cptr) *cptr = vptr;
1658	if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1659	if (alloc) *alloc = SWIG_OLDOBJ;
1660	return SWIG_OK;
1661      }
1662    }
1663  }
1664  return SWIG_TypeError;
1665}
1666
1667
1668
1669
1670
1671SWIGINTERNINLINE SV *
1672SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1673{
1674  SV *obj = sv_newmortal();
1675  if (carray) {
1676    if (size && (carray[size - 1] == 0)) {
1677      sv_setpv(obj, carray);
1678    } else {
1679      char *tmp = (char *)malloc((size + 1)*sizeof(char));
1680      memcpy(tmp, carray, size);
1681      tmp[size] = 0;
1682      sv_setpv(obj, tmp);
1683      free((char*)tmp);
1684    }
1685  } else {
1686    sv_setsv(obj, &PL_sv_undef);
1687  }
1688  return obj;
1689}
1690
1691
1692SWIGINTERNINLINE SV *
1693SWIG_FromCharPtr(const char *cptr)
1694{
1695  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1696}
1697
1698
1699SWIGINTERN int
1700SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1701{
1702  if (SvIOK(obj)) {
1703    if (val) *val = SvIV(obj);
1704    return SWIG_OK;
1705  } else {
1706    int dispatch = 0;
1707    const char *nptr = SvPV(obj, PL_na);
1708    if (nptr) {
1709      char *endptr;
1710      long v = strtol(nptr, &endptr,0);
1711      if (errno == ERANGE) {
1712	errno = 0;
1713	return SWIG_OverflowError;
1714      } else {
1715	if (*endptr == '\0') {
1716	  if (val) *val = v;
1717	  return SWIG_Str2NumCast(SWIG_OK);
1718	}
1719      }
1720    }
1721    if (!dispatch) {
1722      double d;
1723      int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1724      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1725	if (val) *val = (long)(d);
1726	return res;
1727      }
1728    }
1729  }
1730  return SWIG_TypeError;
1731}
1732
1733
1734SWIGINTERN int
1735SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1736{
1737  long v;
1738  int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1739  if (SWIG_IsOK(res)) {
1740    if ((v < INT_MIN || v > INT_MAX)) {
1741      return SWIG_OverflowError;
1742    } else {
1743      if (val) *val = (int)(v);
1744    }
1745  }
1746  return res;
1747}
1748
1749
1750SWIGINTERNINLINE int
1751SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
1752{
1753  unsigned long v;
1754  int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
1755  if (SWIG_IsOK(res) && val) *val = (size_t)(v);
1756  return res;
1757}
1758
1759#ifdef PERL_OBJECT
1760#define MAGIC_CLASS _wrap_netpgpperl_var::
1761class _wrap_netpgpperl_var : public CPerlObj {
1762public:
1763#else
1764#define MAGIC_CLASS
1765#endif
1766SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
1767    MAGIC_PPERL
1768    croak("Value is read-only.");
1769    return 0;
1770}
1771
1772
1773#ifdef PERL_OBJECT
1774};
1775#endif
1776
1777#ifdef __cplusplus
1778extern "C" {
1779#endif
1780XS(_wrap_netpgp_t_c_set) {
1781  {
1782    netpgp_t *arg1 = (netpgp_t *) 0 ;
1783    unsigned int arg2 ;
1784    void *argp1 = 0 ;
1785    int res1 = 0 ;
1786    unsigned int val2 ;
1787    int ecode2 = 0 ;
1788    int argvi = 0;
1789    dXSARGS;
1790
1791    if ((items < 2) || (items > 2)) {
1792      SWIG_croak("Usage: netpgp_t_c_set(self,c);");
1793    }
1794    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1795    if (!SWIG_IsOK(res1)) {
1796      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_c_set" "', argument " "1"" of type '" "netpgp_t *""'");
1797    }
1798    arg1 = (netpgp_t *)(argp1);
1799    ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
1800    if (!SWIG_IsOK(ecode2)) {
1801      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "netpgp_t_c_set" "', argument " "2"" of type '" "unsigned int""'");
1802    }
1803    arg2 = (unsigned int)(val2);
1804    if (arg1) (arg1)->c = arg2;
1805
1806
1807
1808
1809    XSRETURN(argvi);
1810  fail:
1811
1812
1813    SWIG_croak_null();
1814  }
1815}
1816
1817
1818XS(_wrap_netpgp_t_c_get) {
1819  {
1820    netpgp_t *arg1 = (netpgp_t *) 0 ;
1821    unsigned int result;
1822    void *argp1 = 0 ;
1823    int res1 = 0 ;
1824    int argvi = 0;
1825    dXSARGS;
1826
1827    if ((items < 1) || (items > 1)) {
1828      SWIG_croak("Usage: netpgp_t_c_get(self);");
1829    }
1830    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1831    if (!SWIG_IsOK(res1)) {
1832      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_c_get" "', argument " "1"" of type '" "netpgp_t *""'");
1833    }
1834    arg1 = (netpgp_t *)(argp1);
1835    result = (unsigned int) ((arg1)->c);
1836    ST(argvi) = SWIG_From_unsigned_SS_int  SWIG_PERL_CALL_ARGS_1((unsigned int)(result)); argvi++ ;
1837
1838    XSRETURN(argvi);
1839  fail:
1840
1841    SWIG_croak_null();
1842  }
1843}
1844
1845
1846XS(_wrap_netpgp_t_size_set) {
1847  {
1848    netpgp_t *arg1 = (netpgp_t *) 0 ;
1849    unsigned int arg2 ;
1850    void *argp1 = 0 ;
1851    int res1 = 0 ;
1852    unsigned int val2 ;
1853    int ecode2 = 0 ;
1854    int argvi = 0;
1855    dXSARGS;
1856
1857    if ((items < 2) || (items > 2)) {
1858      SWIG_croak("Usage: netpgp_t_size_set(self,size);");
1859    }
1860    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1861    if (!SWIG_IsOK(res1)) {
1862      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_size_set" "', argument " "1"" of type '" "netpgp_t *""'");
1863    }
1864    arg1 = (netpgp_t *)(argp1);
1865    ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
1866    if (!SWIG_IsOK(ecode2)) {
1867      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "netpgp_t_size_set" "', argument " "2"" of type '" "unsigned int""'");
1868    }
1869    arg2 = (unsigned int)(val2);
1870    if (arg1) (arg1)->size = arg2;
1871
1872
1873
1874
1875    XSRETURN(argvi);
1876  fail:
1877
1878
1879    SWIG_croak_null();
1880  }
1881}
1882
1883
1884XS(_wrap_netpgp_t_size_get) {
1885  {
1886    netpgp_t *arg1 = (netpgp_t *) 0 ;
1887    unsigned int result;
1888    void *argp1 = 0 ;
1889    int res1 = 0 ;
1890    int argvi = 0;
1891    dXSARGS;
1892
1893    if ((items < 1) || (items > 1)) {
1894      SWIG_croak("Usage: netpgp_t_size_get(self);");
1895    }
1896    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1897    if (!SWIG_IsOK(res1)) {
1898      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_size_get" "', argument " "1"" of type '" "netpgp_t *""'");
1899    }
1900    arg1 = (netpgp_t *)(argp1);
1901    result = (unsigned int) ((arg1)->size);
1902    ST(argvi) = SWIG_From_unsigned_SS_int  SWIG_PERL_CALL_ARGS_1((unsigned int)(result)); argvi++ ;
1903
1904    XSRETURN(argvi);
1905  fail:
1906
1907    SWIG_croak_null();
1908  }
1909}
1910
1911
1912XS(_wrap_netpgp_t_name_set) {
1913  {
1914    netpgp_t *arg1 = (netpgp_t *) 0 ;
1915    char **arg2 = (char **) 0 ;
1916    void *argp1 = 0 ;
1917    int res1 = 0 ;
1918    void *argp2 = 0 ;
1919    int res2 = 0 ;
1920    int argvi = 0;
1921    dXSARGS;
1922
1923    if ((items < 2) || (items > 2)) {
1924      SWIG_croak("Usage: netpgp_t_name_set(self,name);");
1925    }
1926    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1927    if (!SWIG_IsOK(res1)) {
1928      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_name_set" "', argument " "1"" of type '" "netpgp_t *""'");
1929    }
1930    arg1 = (netpgp_t *)(argp1);
1931    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_char, 0 |  0 );
1932    if (!SWIG_IsOK(res2)) {
1933      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_name_set" "', argument " "2"" of type '" "char **""'");
1934    }
1935    arg2 = (char **)(argp2);
1936    if (arg1) (arg1)->name = arg2;
1937
1938
1939
1940
1941    XSRETURN(argvi);
1942  fail:
1943
1944
1945    SWIG_croak_null();
1946  }
1947}
1948
1949
1950XS(_wrap_netpgp_t_name_get) {
1951  {
1952    netpgp_t *arg1 = (netpgp_t *) 0 ;
1953    char **result = 0 ;
1954    void *argp1 = 0 ;
1955    int res1 = 0 ;
1956    int argvi = 0;
1957    dXSARGS;
1958
1959    if ((items < 1) || (items > 1)) {
1960      SWIG_croak("Usage: netpgp_t_name_get(self);");
1961    }
1962    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1963    if (!SWIG_IsOK(res1)) {
1964      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_name_get" "', argument " "1"" of type '" "netpgp_t *""'");
1965    }
1966    arg1 = (netpgp_t *)(argp1);
1967    result = (char **) ((arg1)->name);
1968    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0); argvi++ ;
1969
1970    XSRETURN(argvi);
1971  fail:
1972
1973    SWIG_croak_null();
1974  }
1975}
1976
1977
1978XS(_wrap_netpgp_t_value_set) {
1979  {
1980    netpgp_t *arg1 = (netpgp_t *) 0 ;
1981    char **arg2 = (char **) 0 ;
1982    void *argp1 = 0 ;
1983    int res1 = 0 ;
1984    void *argp2 = 0 ;
1985    int res2 = 0 ;
1986    int argvi = 0;
1987    dXSARGS;
1988
1989    if ((items < 2) || (items > 2)) {
1990      SWIG_croak("Usage: netpgp_t_value_set(self,value);");
1991    }
1992    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1993    if (!SWIG_IsOK(res1)) {
1994      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_value_set" "', argument " "1"" of type '" "netpgp_t *""'");
1995    }
1996    arg1 = (netpgp_t *)(argp1);
1997    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_p_char, 0 |  0 );
1998    if (!SWIG_IsOK(res2)) {
1999      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_value_set" "', argument " "2"" of type '" "char **""'");
2000    }
2001    arg2 = (char **)(argp2);
2002    if (arg1) (arg1)->value = arg2;
2003
2004
2005
2006
2007    XSRETURN(argvi);
2008  fail:
2009
2010
2011    SWIG_croak_null();
2012  }
2013}
2014
2015
2016XS(_wrap_netpgp_t_value_get) {
2017  {
2018    netpgp_t *arg1 = (netpgp_t *) 0 ;
2019    char **result = 0 ;
2020    void *argp1 = 0 ;
2021    int res1 = 0 ;
2022    int argvi = 0;
2023    dXSARGS;
2024
2025    if ((items < 1) || (items > 1)) {
2026      SWIG_croak("Usage: netpgp_t_value_get(self);");
2027    }
2028    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2029    if (!SWIG_IsOK(res1)) {
2030      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_value_get" "', argument " "1"" of type '" "netpgp_t *""'");
2031    }
2032    arg1 = (netpgp_t *)(argp1);
2033    result = (char **) ((arg1)->value);
2034    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0); argvi++ ;
2035
2036    XSRETURN(argvi);
2037  fail:
2038
2039    SWIG_croak_null();
2040  }
2041}
2042
2043
2044XS(_wrap_netpgp_t_pubring_set) {
2045  {
2046    netpgp_t *arg1 = (netpgp_t *) 0 ;
2047    void *arg2 = (void *) 0 ;
2048    void *argp1 = 0 ;
2049    int res1 = 0 ;
2050    int res2 ;
2051    int argvi = 0;
2052    dXSARGS;
2053
2054    if ((items < 2) || (items > 2)) {
2055      SWIG_croak("Usage: netpgp_t_pubring_set(self,pubring);");
2056    }
2057    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2058    if (!SWIG_IsOK(res1)) {
2059      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_pubring_set" "', argument " "1"" of type '" "netpgp_t *""'");
2060    }
2061    arg1 = (netpgp_t *)(argp1);
2062    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
2063    if (!SWIG_IsOK(res2)) {
2064      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_pubring_set" "', argument " "2"" of type '" "void *""'");
2065    }
2066    if (arg1) (arg1)->pubring = arg2;
2067
2068
2069
2070
2071    XSRETURN(argvi);
2072  fail:
2073
2074
2075    SWIG_croak_null();
2076  }
2077}
2078
2079
2080XS(_wrap_netpgp_t_pubring_get) {
2081  {
2082    netpgp_t *arg1 = (netpgp_t *) 0 ;
2083    void *result = 0 ;
2084    void *argp1 = 0 ;
2085    int res1 = 0 ;
2086    int argvi = 0;
2087    dXSARGS;
2088
2089    if ((items < 1) || (items > 1)) {
2090      SWIG_croak("Usage: netpgp_t_pubring_get(self);");
2091    }
2092    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2093    if (!SWIG_IsOK(res1)) {
2094      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_pubring_get" "', argument " "1"" of type '" "netpgp_t *""'");
2095    }
2096    arg1 = (netpgp_t *)(argp1);
2097    result = (void *) ((arg1)->pubring);
2098    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
2099
2100    XSRETURN(argvi);
2101  fail:
2102
2103    SWIG_croak_null();
2104  }
2105}
2106
2107
2108XS(_wrap_netpgp_t_secring_set) {
2109  {
2110    netpgp_t *arg1 = (netpgp_t *) 0 ;
2111    void *arg2 = (void *) 0 ;
2112    void *argp1 = 0 ;
2113    int res1 = 0 ;
2114    int res2 ;
2115    int argvi = 0;
2116    dXSARGS;
2117
2118    if ((items < 2) || (items > 2)) {
2119      SWIG_croak("Usage: netpgp_t_secring_set(self,secring);");
2120    }
2121    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2122    if (!SWIG_IsOK(res1)) {
2123      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_secring_set" "', argument " "1"" of type '" "netpgp_t *""'");
2124    }
2125    arg1 = (netpgp_t *)(argp1);
2126    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
2127    if (!SWIG_IsOK(res2)) {
2128      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_secring_set" "', argument " "2"" of type '" "void *""'");
2129    }
2130    if (arg1) (arg1)->secring = arg2;
2131
2132
2133
2134
2135    XSRETURN(argvi);
2136  fail:
2137
2138
2139    SWIG_croak_null();
2140  }
2141}
2142
2143
2144XS(_wrap_netpgp_t_secring_get) {
2145  {
2146    netpgp_t *arg1 = (netpgp_t *) 0 ;
2147    void *result = 0 ;
2148    void *argp1 = 0 ;
2149    int res1 = 0 ;
2150    int argvi = 0;
2151    dXSARGS;
2152
2153    if ((items < 1) || (items > 1)) {
2154      SWIG_croak("Usage: netpgp_t_secring_get(self);");
2155    }
2156    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2157    if (!SWIG_IsOK(res1)) {
2158      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_secring_get" "', argument " "1"" of type '" "netpgp_t *""'");
2159    }
2160    arg1 = (netpgp_t *)(argp1);
2161    result = (void *) ((arg1)->secring);
2162    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
2163
2164    XSRETURN(argvi);
2165  fail:
2166
2167    SWIG_croak_null();
2168  }
2169}
2170
2171
2172XS(_wrap_netpgp_t_io_set) {
2173  {
2174    netpgp_t *arg1 = (netpgp_t *) 0 ;
2175    void *arg2 = (void *) 0 ;
2176    void *argp1 = 0 ;
2177    int res1 = 0 ;
2178    int res2 ;
2179    int argvi = 0;
2180    dXSARGS;
2181
2182    if ((items < 2) || (items > 2)) {
2183      SWIG_croak("Usage: netpgp_t_io_set(self,io);");
2184    }
2185    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2186    if (!SWIG_IsOK(res1)) {
2187      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_io_set" "', argument " "1"" of type '" "netpgp_t *""'");
2188    }
2189    arg1 = (netpgp_t *)(argp1);
2190    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
2191    if (!SWIG_IsOK(res2)) {
2192      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_io_set" "', argument " "2"" of type '" "void *""'");
2193    }
2194    if (arg1) (arg1)->io = arg2;
2195
2196
2197
2198
2199    XSRETURN(argvi);
2200  fail:
2201
2202
2203    SWIG_croak_null();
2204  }
2205}
2206
2207
2208XS(_wrap_netpgp_t_io_get) {
2209  {
2210    netpgp_t *arg1 = (netpgp_t *) 0 ;
2211    void *result = 0 ;
2212    void *argp1 = 0 ;
2213    int res1 = 0 ;
2214    int argvi = 0;
2215    dXSARGS;
2216
2217    if ((items < 1) || (items > 1)) {
2218      SWIG_croak("Usage: netpgp_t_io_get(self);");
2219    }
2220    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2221    if (!SWIG_IsOK(res1)) {
2222      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_io_get" "', argument " "1"" of type '" "netpgp_t *""'");
2223    }
2224    arg1 = (netpgp_t *)(argp1);
2225    result = (void *) ((arg1)->io);
2226    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
2227
2228    XSRETURN(argvi);
2229  fail:
2230
2231    SWIG_croak_null();
2232  }
2233}
2234
2235
2236XS(_wrap_netpgp_t_passfp_set) {
2237  {
2238    netpgp_t *arg1 = (netpgp_t *) 0 ;
2239    void *arg2 = (void *) 0 ;
2240    void *argp1 = 0 ;
2241    int res1 = 0 ;
2242    int res2 ;
2243    int argvi = 0;
2244    dXSARGS;
2245
2246    if ((items < 2) || (items > 2)) {
2247      SWIG_croak("Usage: netpgp_t_passfp_set(self,passfp);");
2248    }
2249    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2250    if (!SWIG_IsOK(res1)) {
2251      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_passfp_set" "', argument " "1"" of type '" "netpgp_t *""'");
2252    }
2253    arg1 = (netpgp_t *)(argp1);
2254    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
2255    if (!SWIG_IsOK(res2)) {
2256      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_passfp_set" "', argument " "2"" of type '" "void *""'");
2257    }
2258    if (arg1) (arg1)->passfp = arg2;
2259
2260
2261
2262
2263    XSRETURN(argvi);
2264  fail:
2265
2266
2267    SWIG_croak_null();
2268  }
2269}
2270
2271
2272XS(_wrap_netpgp_t_passfp_get) {
2273  {
2274    netpgp_t *arg1 = (netpgp_t *) 0 ;
2275    void *result = 0 ;
2276    void *argp1 = 0 ;
2277    int res1 = 0 ;
2278    int argvi = 0;
2279    dXSARGS;
2280
2281    if ((items < 1) || (items > 1)) {
2282      SWIG_croak("Usage: netpgp_t_passfp_get(self);");
2283    }
2284    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2285    if (!SWIG_IsOK(res1)) {
2286      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_passfp_get" "', argument " "1"" of type '" "netpgp_t *""'");
2287    }
2288    arg1 = (netpgp_t *)(argp1);
2289    result = (void *) ((arg1)->passfp);
2290    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0); argvi++ ;
2291
2292    XSRETURN(argvi);
2293  fail:
2294
2295    SWIG_croak_null();
2296  }
2297}
2298
2299
2300XS(_wrap_new_netpgp_t) {
2301  {
2302    netpgp_t *result = 0 ;
2303    int argvi = 0;
2304    dXSARGS;
2305
2306    if ((items < 0) || (items > 0)) {
2307      SWIG_croak("Usage: new_netpgp_t();");
2308    }
2309    result = (netpgp_t *)(netpgp_t *) calloc(1, sizeof(netpgp_t));
2310    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_netpgp_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
2311    XSRETURN(argvi);
2312  fail:
2313    SWIG_croak_null();
2314  }
2315}
2316
2317
2318XS(_wrap_delete_netpgp_t) {
2319  {
2320    netpgp_t *arg1 = (netpgp_t *) 0 ;
2321    void *argp1 = 0 ;
2322    int res1 = 0 ;
2323    int argvi = 0;
2324    dXSARGS;
2325
2326    if ((items < 1) || (items > 1)) {
2327      SWIG_croak("Usage: delete_netpgp_t(self);");
2328    }
2329    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, SWIG_POINTER_DISOWN |  0 );
2330    if (!SWIG_IsOK(res1)) {
2331      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_netpgp_t" "', argument " "1"" of type '" "netpgp_t *""'");
2332    }
2333    arg1 = (netpgp_t *)(argp1);
2334    free((char *) arg1);
2335
2336
2337
2338    XSRETURN(argvi);
2339  fail:
2340
2341    SWIG_croak_null();
2342  }
2343}
2344
2345
2346XS(_wrap_netpgp_init) {
2347  {
2348    netpgp_t *arg1 = (netpgp_t *) 0 ;
2349    int result;
2350    void *argp1 = 0 ;
2351    int res1 = 0 ;
2352    int argvi = 0;
2353    dXSARGS;
2354
2355    if ((items < 1) || (items > 1)) {
2356      SWIG_croak("Usage: netpgp_init(netpgp_t *);");
2357    }
2358    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2359    if (!SWIG_IsOK(res1)) {
2360      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_init" "', argument " "1"" of type '" "netpgp_t *""'");
2361    }
2362    arg1 = (netpgp_t *)(argp1);
2363    result = (int)netpgp_init(arg1);
2364    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2365
2366    XSRETURN(argvi);
2367  fail:
2368
2369    SWIG_croak_null();
2370  }
2371}
2372
2373
2374XS(_wrap_netpgp_end) {
2375  {
2376    netpgp_t *arg1 = (netpgp_t *) 0 ;
2377    int result;
2378    void *argp1 = 0 ;
2379    int res1 = 0 ;
2380    int argvi = 0;
2381    dXSARGS;
2382
2383    if ((items < 1) || (items > 1)) {
2384      SWIG_croak("Usage: netpgp_end(netpgp_t *);");
2385    }
2386    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2387    if (!SWIG_IsOK(res1)) {
2388      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_end" "', argument " "1"" of type '" "netpgp_t *""'");
2389    }
2390    arg1 = (netpgp_t *)(argp1);
2391    result = (int)netpgp_end(arg1);
2392    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2393
2394    XSRETURN(argvi);
2395  fail:
2396
2397    SWIG_croak_null();
2398  }
2399}
2400
2401
2402XS(_wrap_netpgp_set_debug) {
2403  {
2404    char *arg1 = (char *) 0 ;
2405    int result;
2406    int res1 ;
2407    char *buf1 = 0 ;
2408    int alloc1 = 0 ;
2409    int argvi = 0;
2410    dXSARGS;
2411
2412    if ((items < 1) || (items > 1)) {
2413      SWIG_croak("Usage: netpgp_set_debug(char const *);");
2414    }
2415    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2416    if (!SWIG_IsOK(res1)) {
2417      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_set_debug" "', argument " "1"" of type '" "char const *""'");
2418    }
2419    arg1 = (char *)(buf1);
2420    result = (int)netpgp_set_debug((char const *)arg1);
2421    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2422    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2423    XSRETURN(argvi);
2424  fail:
2425    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2426    SWIG_croak_null();
2427  }
2428}
2429
2430
2431XS(_wrap_netpgp_get_debug) {
2432  {
2433    char *arg1 = (char *) 0 ;
2434    int result;
2435    int res1 ;
2436    char *buf1 = 0 ;
2437    int alloc1 = 0 ;
2438    int argvi = 0;
2439    dXSARGS;
2440
2441    if ((items < 1) || (items > 1)) {
2442      SWIG_croak("Usage: netpgp_get_debug(char const *);");
2443    }
2444    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2445    if (!SWIG_IsOK(res1)) {
2446      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_get_debug" "', argument " "1"" of type '" "char const *""'");
2447    }
2448    arg1 = (char *)(buf1);
2449    result = (int)netpgp_get_debug((char const *)arg1);
2450    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2451    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2452    XSRETURN(argvi);
2453  fail:
2454    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2455    SWIG_croak_null();
2456  }
2457}
2458
2459
2460XS(_wrap_netpgp_get_info) {
2461  {
2462    char *arg1 = (char *) 0 ;
2463    char *result = 0 ;
2464    int res1 ;
2465    char *buf1 = 0 ;
2466    int alloc1 = 0 ;
2467    int argvi = 0;
2468    dXSARGS;
2469
2470    if ((items < 1) || (items > 1)) {
2471      SWIG_croak("Usage: netpgp_get_info(char const *);");
2472    }
2473    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2474    if (!SWIG_IsOK(res1)) {
2475      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_get_info" "', argument " "1"" of type '" "char const *""'");
2476    }
2477    arg1 = (char *)(buf1);
2478    result = (char *)netpgp_get_info((char const *)arg1);
2479    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2480    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2481    XSRETURN(argvi);
2482  fail:
2483    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2484    SWIG_croak_null();
2485  }
2486}
2487
2488
2489XS(_wrap_netpgp_list_packets) {
2490  {
2491    netpgp_t *arg1 = (netpgp_t *) 0 ;
2492    char *arg2 = (char *) 0 ;
2493    int arg3 ;
2494    char *arg4 = (char *) 0 ;
2495    int result;
2496    void *argp1 = 0 ;
2497    int res1 = 0 ;
2498    int res2 ;
2499    char *buf2 = 0 ;
2500    int alloc2 = 0 ;
2501    int val3 ;
2502    int ecode3 = 0 ;
2503    int res4 ;
2504    char *buf4 = 0 ;
2505    int alloc4 = 0 ;
2506    int argvi = 0;
2507    dXSARGS;
2508
2509    if ((items < 4) || (items > 4)) {
2510      SWIG_croak("Usage: netpgp_list_packets(netpgp_t *,char *,int,char *);");
2511    }
2512    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2513    if (!SWIG_IsOK(res1)) {
2514      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_list_packets" "', argument " "1"" of type '" "netpgp_t *""'");
2515    }
2516    arg1 = (netpgp_t *)(argp1);
2517    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2518    if (!SWIG_IsOK(res2)) {
2519      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_list_packets" "', argument " "2"" of type '" "char *""'");
2520    }
2521    arg2 = (char *)(buf2);
2522    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2523    if (!SWIG_IsOK(ecode3)) {
2524      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "netpgp_list_packets" "', argument " "3"" of type '" "int""'");
2525    }
2526    arg3 = (int)(val3);
2527    res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
2528    if (!SWIG_IsOK(res4)) {
2529      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "netpgp_list_packets" "', argument " "4"" of type '" "char *""'");
2530    }
2531    arg4 = (char *)(buf4);
2532    result = (int)netpgp_list_packets(arg1,arg2,arg3,arg4);
2533    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2534
2535    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2536
2537    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2538    XSRETURN(argvi);
2539  fail:
2540
2541    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2542
2543    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2544    SWIG_croak_null();
2545  }
2546}
2547
2548
2549XS(_wrap_netpgp_setvar) {
2550  {
2551    netpgp_t *arg1 = (netpgp_t *) 0 ;
2552    char *arg2 = (char *) 0 ;
2553    char *arg3 = (char *) 0 ;
2554    int result;
2555    void *argp1 = 0 ;
2556    int res1 = 0 ;
2557    int res2 ;
2558    char *buf2 = 0 ;
2559    int alloc2 = 0 ;
2560    int res3 ;
2561    char *buf3 = 0 ;
2562    int alloc3 = 0 ;
2563    int argvi = 0;
2564    dXSARGS;
2565
2566    if ((items < 3) || (items > 3)) {
2567      SWIG_croak("Usage: netpgp_setvar(netpgp_t *,char const *,char const *);");
2568    }
2569    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2570    if (!SWIG_IsOK(res1)) {
2571      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_setvar" "', argument " "1"" of type '" "netpgp_t *""'");
2572    }
2573    arg1 = (netpgp_t *)(argp1);
2574    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2575    if (!SWIG_IsOK(res2)) {
2576      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_setvar" "', argument " "2"" of type '" "char const *""'");
2577    }
2578    arg2 = (char *)(buf2);
2579    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2580    if (!SWIG_IsOK(res3)) {
2581      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_setvar" "', argument " "3"" of type '" "char const *""'");
2582    }
2583    arg3 = (char *)(buf3);
2584    result = (int)netpgp_setvar(arg1,(char const *)arg2,(char const *)arg3);
2585    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2586
2587    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2588    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2589    XSRETURN(argvi);
2590  fail:
2591
2592    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2593    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2594    SWIG_croak_null();
2595  }
2596}
2597
2598
2599XS(_wrap_netpgp_getvar) {
2600  {
2601    netpgp_t *arg1 = (netpgp_t *) 0 ;
2602    char *arg2 = (char *) 0 ;
2603    char *result = 0 ;
2604    void *argp1 = 0 ;
2605    int res1 = 0 ;
2606    int res2 ;
2607    char *buf2 = 0 ;
2608    int alloc2 = 0 ;
2609    int argvi = 0;
2610    dXSARGS;
2611
2612    if ((items < 2) || (items > 2)) {
2613      SWIG_croak("Usage: netpgp_getvar(netpgp_t *,char const *);");
2614    }
2615    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2616    if (!SWIG_IsOK(res1)) {
2617      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_getvar" "', argument " "1"" of type '" "netpgp_t *""'");
2618    }
2619    arg1 = (netpgp_t *)(argp1);
2620    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2621    if (!SWIG_IsOK(res2)) {
2622      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_getvar" "', argument " "2"" of type '" "char const *""'");
2623    }
2624    arg2 = (char *)(buf2);
2625    result = (char *)netpgp_getvar(arg1,(char const *)arg2);
2626    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2627
2628    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2629    XSRETURN(argvi);
2630  fail:
2631
2632    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2633    SWIG_croak_null();
2634  }
2635}
2636
2637
2638XS(_wrap_netpgp_list_keys) {
2639  {
2640    netpgp_t *arg1 = (netpgp_t *) 0 ;
2641    int result;
2642    void *argp1 = 0 ;
2643    int res1 = 0 ;
2644    int argvi = 0;
2645    dXSARGS;
2646
2647    if ((items < 1) || (items > 1)) {
2648      SWIG_croak("Usage: netpgp_list_keys(netpgp_t *);");
2649    }
2650    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2651    if (!SWIG_IsOK(res1)) {
2652      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_list_keys" "', argument " "1"" of type '" "netpgp_t *""'");
2653    }
2654    arg1 = (netpgp_t *)(argp1);
2655    result = (int)netpgp_list_keys(arg1);
2656    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2657
2658    XSRETURN(argvi);
2659  fail:
2660
2661    SWIG_croak_null();
2662  }
2663}
2664
2665
2666XS(_wrap_netpgp_list_sigs) {
2667  {
2668    netpgp_t *arg1 = (netpgp_t *) 0 ;
2669    char *arg2 = (char *) 0 ;
2670    int result;
2671    void *argp1 = 0 ;
2672    int res1 = 0 ;
2673    int res2 ;
2674    char *buf2 = 0 ;
2675    int alloc2 = 0 ;
2676    int argvi = 0;
2677    dXSARGS;
2678
2679    if ((items < 2) || (items > 2)) {
2680      SWIG_croak("Usage: netpgp_list_sigs(netpgp_t *,char const *);");
2681    }
2682    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2683    if (!SWIG_IsOK(res1)) {
2684      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_list_sigs" "', argument " "1"" of type '" "netpgp_t *""'");
2685    }
2686    arg1 = (netpgp_t *)(argp1);
2687    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2688    if (!SWIG_IsOK(res2)) {
2689      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_list_sigs" "', argument " "2"" of type '" "char const *""'");
2690    }
2691    arg2 = (char *)(buf2);
2692    result = (int)netpgp_list_sigs(arg1,(char const *)arg2);
2693    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2694
2695    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2696    XSRETURN(argvi);
2697  fail:
2698
2699    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2700    SWIG_croak_null();
2701  }
2702}
2703
2704
2705XS(_wrap_netpgp_find_key) {
2706  {
2707    netpgp_t *arg1 = (netpgp_t *) 0 ;
2708    char *arg2 = (char *) 0 ;
2709    int result;
2710    void *argp1 = 0 ;
2711    int res1 = 0 ;
2712    int res2 ;
2713    char *buf2 = 0 ;
2714    int alloc2 = 0 ;
2715    int argvi = 0;
2716    dXSARGS;
2717
2718    if ((items < 2) || (items > 2)) {
2719      SWIG_croak("Usage: netpgp_find_key(netpgp_t *,char *);");
2720    }
2721    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2722    if (!SWIG_IsOK(res1)) {
2723      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_find_key" "', argument " "1"" of type '" "netpgp_t *""'");
2724    }
2725    arg1 = (netpgp_t *)(argp1);
2726    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2727    if (!SWIG_IsOK(res2)) {
2728      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_find_key" "', argument " "2"" of type '" "char *""'");
2729    }
2730    arg2 = (char *)(buf2);
2731    result = (int)netpgp_find_key(arg1,arg2);
2732    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2733
2734    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2735    XSRETURN(argvi);
2736  fail:
2737
2738    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2739    SWIG_croak_null();
2740  }
2741}
2742
2743
2744XS(_wrap_netpgp_get_key) {
2745  {
2746    netpgp_t *arg1 = (netpgp_t *) 0 ;
2747    char *arg2 = (char *) 0 ;
2748    char *result = 0 ;
2749    void *argp1 = 0 ;
2750    int res1 = 0 ;
2751    int res2 ;
2752    char *buf2 = 0 ;
2753    int alloc2 = 0 ;
2754    int argvi = 0;
2755    dXSARGS;
2756
2757    if ((items < 2) || (items > 2)) {
2758      SWIG_croak("Usage: netpgp_get_key(netpgp_t *,char const *);");
2759    }
2760    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2761    if (!SWIG_IsOK(res1)) {
2762      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_get_key" "', argument " "1"" of type '" "netpgp_t *""'");
2763    }
2764    arg1 = (netpgp_t *)(argp1);
2765    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2766    if (!SWIG_IsOK(res2)) {
2767      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_get_key" "', argument " "2"" of type '" "char const *""'");
2768    }
2769    arg2 = (char *)(buf2);
2770    result = (char *)netpgp_get_key(arg1,(char const *)arg2);
2771    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2772
2773    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2774    XSRETURN(argvi);
2775  fail:
2776
2777    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2778    SWIG_croak_null();
2779  }
2780}
2781
2782
2783XS(_wrap_netpgp_export_key) {
2784  {
2785    netpgp_t *arg1 = (netpgp_t *) 0 ;
2786    char *arg2 = (char *) 0 ;
2787    int result;
2788    void *argp1 = 0 ;
2789    int res1 = 0 ;
2790    int res2 ;
2791    char *buf2 = 0 ;
2792    int alloc2 = 0 ;
2793    int argvi = 0;
2794    dXSARGS;
2795
2796    if ((items < 2) || (items > 2)) {
2797      SWIG_croak("Usage: netpgp_export_key(netpgp_t *,char *);");
2798    }
2799    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2800    if (!SWIG_IsOK(res1)) {
2801      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_export_key" "', argument " "1"" of type '" "netpgp_t *""'");
2802    }
2803    arg1 = (netpgp_t *)(argp1);
2804    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2805    if (!SWIG_IsOK(res2)) {
2806      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_export_key" "', argument " "2"" of type '" "char *""'");
2807    }
2808    arg2 = (char *)(buf2);
2809    result = (int)netpgp_export_key(arg1,arg2);
2810    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2811
2812    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2813    XSRETURN(argvi);
2814  fail:
2815
2816    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2817    SWIG_croak_null();
2818  }
2819}
2820
2821
2822XS(_wrap_netpgp_import_key) {
2823  {
2824    netpgp_t *arg1 = (netpgp_t *) 0 ;
2825    char *arg2 = (char *) 0 ;
2826    int result;
2827    void *argp1 = 0 ;
2828    int res1 = 0 ;
2829    int res2 ;
2830    char *buf2 = 0 ;
2831    int alloc2 = 0 ;
2832    int argvi = 0;
2833    dXSARGS;
2834
2835    if ((items < 2) || (items > 2)) {
2836      SWIG_croak("Usage: netpgp_import_key(netpgp_t *,char *);");
2837    }
2838    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2839    if (!SWIG_IsOK(res1)) {
2840      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_import_key" "', argument " "1"" of type '" "netpgp_t *""'");
2841    }
2842    arg1 = (netpgp_t *)(argp1);
2843    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2844    if (!SWIG_IsOK(res2)) {
2845      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_import_key" "', argument " "2"" of type '" "char *""'");
2846    }
2847    arg2 = (char *)(buf2);
2848    result = (int)netpgp_import_key(arg1,arg2);
2849    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2850
2851    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2852    XSRETURN(argvi);
2853  fail:
2854
2855    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2856    SWIG_croak_null();
2857  }
2858}
2859
2860
2861XS(_wrap_netpgp_generate_key) {
2862  {
2863    netpgp_t *arg1 = (netpgp_t *) 0 ;
2864    char *arg2 = (char *) 0 ;
2865    int arg3 ;
2866    int result;
2867    void *argp1 = 0 ;
2868    int res1 = 0 ;
2869    int res2 ;
2870    char *buf2 = 0 ;
2871    int alloc2 = 0 ;
2872    int val3 ;
2873    int ecode3 = 0 ;
2874    int argvi = 0;
2875    dXSARGS;
2876
2877    if ((items < 3) || (items > 3)) {
2878      SWIG_croak("Usage: netpgp_generate_key(netpgp_t *,char *,int);");
2879    }
2880    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2881    if (!SWIG_IsOK(res1)) {
2882      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_generate_key" "', argument " "1"" of type '" "netpgp_t *""'");
2883    }
2884    arg1 = (netpgp_t *)(argp1);
2885    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2886    if (!SWIG_IsOK(res2)) {
2887      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_generate_key" "', argument " "2"" of type '" "char *""'");
2888    }
2889    arg2 = (char *)(buf2);
2890    ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
2891    if (!SWIG_IsOK(ecode3)) {
2892      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "netpgp_generate_key" "', argument " "3"" of type '" "int""'");
2893    }
2894    arg3 = (int)(val3);
2895    result = (int)netpgp_generate_key(arg1,arg2,arg3);
2896    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2897
2898    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2899
2900    XSRETURN(argvi);
2901  fail:
2902
2903    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2904
2905    SWIG_croak_null();
2906  }
2907}
2908
2909
2910XS(_wrap_netpgp_encrypt_file) {
2911  {
2912    netpgp_t *arg1 = (netpgp_t *) 0 ;
2913    char *arg2 = (char *) 0 ;
2914    char *arg3 = (char *) 0 ;
2915    char *arg4 = (char *) 0 ;
2916    int arg5 ;
2917    int result;
2918    void *argp1 = 0 ;
2919    int res1 = 0 ;
2920    int res2 ;
2921    char *buf2 = 0 ;
2922    int alloc2 = 0 ;
2923    int res3 ;
2924    char *buf3 = 0 ;
2925    int alloc3 = 0 ;
2926    int res4 ;
2927    char *buf4 = 0 ;
2928    int alloc4 = 0 ;
2929    int val5 ;
2930    int ecode5 = 0 ;
2931    int argvi = 0;
2932    dXSARGS;
2933
2934    if ((items < 5) || (items > 5)) {
2935      SWIG_croak("Usage: netpgp_encrypt_file(netpgp_t *,char const *,char const *,char *,int);");
2936    }
2937    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2938    if (!SWIG_IsOK(res1)) {
2939      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_encrypt_file" "', argument " "1"" of type '" "netpgp_t *""'");
2940    }
2941    arg1 = (netpgp_t *)(argp1);
2942    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2943    if (!SWIG_IsOK(res2)) {
2944      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_encrypt_file" "', argument " "2"" of type '" "char const *""'");
2945    }
2946    arg2 = (char *)(buf2);
2947    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2948    if (!SWIG_IsOK(res3)) {
2949      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_encrypt_file" "', argument " "3"" of type '" "char const *""'");
2950    }
2951    arg3 = (char *)(buf3);
2952    res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
2953    if (!SWIG_IsOK(res4)) {
2954      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "netpgp_encrypt_file" "', argument " "4"" of type '" "char *""'");
2955    }
2956    arg4 = (char *)(buf4);
2957    ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
2958    if (!SWIG_IsOK(ecode5)) {
2959      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "netpgp_encrypt_file" "', argument " "5"" of type '" "int""'");
2960    }
2961    arg5 = (int)(val5);
2962    result = (int)netpgp_encrypt_file(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
2963    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
2964
2965    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2966    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2967    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2968
2969    XSRETURN(argvi);
2970  fail:
2971
2972    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2973    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2974    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2975
2976    SWIG_croak_null();
2977  }
2978}
2979
2980
2981XS(_wrap_netpgp_decrypt_file) {
2982  {
2983    netpgp_t *arg1 = (netpgp_t *) 0 ;
2984    char *arg2 = (char *) 0 ;
2985    char *arg3 = (char *) 0 ;
2986    int arg4 ;
2987    int result;
2988    void *argp1 = 0 ;
2989    int res1 = 0 ;
2990    int res2 ;
2991    char *buf2 = 0 ;
2992    int alloc2 = 0 ;
2993    int res3 ;
2994    char *buf3 = 0 ;
2995    int alloc3 = 0 ;
2996    int val4 ;
2997    int ecode4 = 0 ;
2998    int argvi = 0;
2999    dXSARGS;
3000
3001    if ((items < 4) || (items > 4)) {
3002      SWIG_croak("Usage: netpgp_decrypt_file(netpgp_t *,char const *,char *,int);");
3003    }
3004    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3005    if (!SWIG_IsOK(res1)) {
3006      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_decrypt_file" "', argument " "1"" of type '" "netpgp_t *""'");
3007    }
3008    arg1 = (netpgp_t *)(argp1);
3009    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3010    if (!SWIG_IsOK(res2)) {
3011      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_decrypt_file" "', argument " "2"" of type '" "char const *""'");
3012    }
3013    arg2 = (char *)(buf2);
3014    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
3015    if (!SWIG_IsOK(res3)) {
3016      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_decrypt_file" "', argument " "3"" of type '" "char *""'");
3017    }
3018    arg3 = (char *)(buf3);
3019    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3020    if (!SWIG_IsOK(ecode4)) {
3021      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_decrypt_file" "', argument " "4"" of type '" "int""'");
3022    }
3023    arg4 = (int)(val4);
3024    result = (int)netpgp_decrypt_file(arg1,(char const *)arg2,arg3,arg4);
3025    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3026
3027    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3028    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3029
3030    XSRETURN(argvi);
3031  fail:
3032
3033    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3034    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3035
3036    SWIG_croak_null();
3037  }
3038}
3039
3040
3041XS(_wrap_netpgp_sign_file) {
3042  {
3043    netpgp_t *arg1 = (netpgp_t *) 0 ;
3044    char *arg2 = (char *) 0 ;
3045    char *arg3 = (char *) 0 ;
3046    char *arg4 = (char *) 0 ;
3047    int arg5 ;
3048    int arg6 ;
3049    int arg7 ;
3050    int result;
3051    void *argp1 = 0 ;
3052    int res1 = 0 ;
3053    int res2 ;
3054    char *buf2 = 0 ;
3055    int alloc2 = 0 ;
3056    int res3 ;
3057    char *buf3 = 0 ;
3058    int alloc3 = 0 ;
3059    int res4 ;
3060    char *buf4 = 0 ;
3061    int alloc4 = 0 ;
3062    int val5 ;
3063    int ecode5 = 0 ;
3064    int val6 ;
3065    int ecode6 = 0 ;
3066    int val7 ;
3067    int ecode7 = 0 ;
3068    int argvi = 0;
3069    dXSARGS;
3070
3071    if ((items < 7) || (items > 7)) {
3072      SWIG_croak("Usage: netpgp_sign_file(netpgp_t *,char const *,char const *,char *,int,int,int);");
3073    }
3074    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3075    if (!SWIG_IsOK(res1)) {
3076      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_sign_file" "', argument " "1"" of type '" "netpgp_t *""'");
3077    }
3078    arg1 = (netpgp_t *)(argp1);
3079    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3080    if (!SWIG_IsOK(res2)) {
3081      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_sign_file" "', argument " "2"" of type '" "char const *""'");
3082    }
3083    arg2 = (char *)(buf2);
3084    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
3085    if (!SWIG_IsOK(res3)) {
3086      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_sign_file" "', argument " "3"" of type '" "char const *""'");
3087    }
3088    arg3 = (char *)(buf3);
3089    res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
3090    if (!SWIG_IsOK(res4)) {
3091      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "netpgp_sign_file" "', argument " "4"" of type '" "char *""'");
3092    }
3093    arg4 = (char *)(buf4);
3094    ecode5 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(4), &val5);
3095    if (!SWIG_IsOK(ecode5)) {
3096      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "netpgp_sign_file" "', argument " "5"" of type '" "int""'");
3097    }
3098    arg5 = (int)(val5);
3099    ecode6 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
3100    if (!SWIG_IsOK(ecode6)) {
3101      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "netpgp_sign_file" "', argument " "6"" of type '" "int""'");
3102    }
3103    arg6 = (int)(val6);
3104    ecode7 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(6), &val7);
3105    if (!SWIG_IsOK(ecode7)) {
3106      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "netpgp_sign_file" "', argument " "7"" of type '" "int""'");
3107    }
3108    arg7 = (int)(val7);
3109    result = (int)netpgp_sign_file(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7);
3110    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3111
3112    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3113    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3114    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3115
3116
3117
3118    XSRETURN(argvi);
3119  fail:
3120
3121    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3122    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3123    if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
3124
3125
3126
3127    SWIG_croak_null();
3128  }
3129}
3130
3131
3132XS(_wrap_netpgp_verify_file) {
3133  {
3134    netpgp_t *arg1 = (netpgp_t *) 0 ;
3135    char *arg2 = (char *) 0 ;
3136    char *arg3 = (char *) 0 ;
3137    int arg4 ;
3138    int result;
3139    void *argp1 = 0 ;
3140    int res1 = 0 ;
3141    int res2 ;
3142    char *buf2 = 0 ;
3143    int alloc2 = 0 ;
3144    int res3 ;
3145    char *buf3 = 0 ;
3146    int alloc3 = 0 ;
3147    int val4 ;
3148    int ecode4 = 0 ;
3149    int argvi = 0;
3150    dXSARGS;
3151
3152    if ((items < 4) || (items > 4)) {
3153      SWIG_croak("Usage: netpgp_verify_file(netpgp_t *,char const *,char const *,int);");
3154    }
3155    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3156    if (!SWIG_IsOK(res1)) {
3157      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_verify_file" "', argument " "1"" of type '" "netpgp_t *""'");
3158    }
3159    arg1 = (netpgp_t *)(argp1);
3160    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3161    if (!SWIG_IsOK(res2)) {
3162      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_verify_file" "', argument " "2"" of type '" "char const *""'");
3163    }
3164    arg2 = (char *)(buf2);
3165    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
3166    if (!SWIG_IsOK(res3)) {
3167      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_verify_file" "', argument " "3"" of type '" "char const *""'");
3168    }
3169    arg3 = (char *)(buf3);
3170    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3171    if (!SWIG_IsOK(ecode4)) {
3172      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_verify_file" "', argument " "4"" of type '" "int""'");
3173    }
3174    arg4 = (int)(val4);
3175    result = (int)netpgp_verify_file(arg1,(char const *)arg2,(char const *)arg3,arg4);
3176    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3177
3178    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3179    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3180
3181    XSRETURN(argvi);
3182  fail:
3183
3184    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3185    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3186
3187    SWIG_croak_null();
3188  }
3189}
3190
3191
3192XS(_wrap_netpgp_sign_memory) {
3193  {
3194    netpgp_t *arg1 = (netpgp_t *) 0 ;
3195    char *arg2 = (char *) 0 ;
3196    char *arg3 = (char *) 0 ;
3197    size_t arg4 ;
3198    char *arg5 = (char *) 0 ;
3199    size_t arg6 ;
3200    unsigned int arg7 ;
3201    unsigned int arg8 ;
3202    int result;
3203    void *argp1 = 0 ;
3204    int res1 = 0 ;
3205    int res2 ;
3206    char *buf2 = 0 ;
3207    int alloc2 = 0 ;
3208    int res3 ;
3209    char *buf3 = 0 ;
3210    int alloc3 = 0 ;
3211    size_t val4 ;
3212    int ecode4 = 0 ;
3213    int res5 ;
3214    char *buf5 = 0 ;
3215    int alloc5 = 0 ;
3216    size_t val6 ;
3217    int ecode6 = 0 ;
3218    unsigned int val7 ;
3219    int ecode7 = 0 ;
3220    unsigned int val8 ;
3221    int ecode8 = 0 ;
3222    int argvi = 0;
3223    dXSARGS;
3224
3225    if ((items < 8) || (items > 8)) {
3226      SWIG_croak("Usage: netpgp_sign_memory(netpgp_t *,char const *,char *,size_t,char *,size_t,unsigned int const,unsigned int const);");
3227    }
3228    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3229    if (!SWIG_IsOK(res1)) {
3230      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_sign_memory" "', argument " "1"" of type '" "netpgp_t *""'");
3231    }
3232    arg1 = (netpgp_t *)(argp1);
3233    res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3234    if (!SWIG_IsOK(res2)) {
3235      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_sign_memory" "', argument " "2"" of type '" "char const *""'");
3236    }
3237    arg2 = (char *)(buf2);
3238    res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
3239    if (!SWIG_IsOK(res3)) {
3240      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_sign_memory" "', argument " "3"" of type '" "char *""'");
3241    }
3242    arg3 = (char *)(buf3);
3243    ecode4 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3244    if (!SWIG_IsOK(ecode4)) {
3245      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_sign_memory" "', argument " "4"" of type '" "size_t""'");
3246    }
3247    arg4 = (size_t)(val4);
3248    res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5);
3249    if (!SWIG_IsOK(res5)) {
3250      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "netpgp_sign_memory" "', argument " "5"" of type '" "char *""'");
3251    }
3252    arg5 = (char *)(buf5);
3253    ecode6 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(5), &val6);
3254    if (!SWIG_IsOK(ecode6)) {
3255      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "netpgp_sign_memory" "', argument " "6"" of type '" "size_t""'");
3256    }
3257    arg6 = (size_t)(val6);
3258    ecode7 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(6), &val7);
3259    if (!SWIG_IsOK(ecode7)) {
3260      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "netpgp_sign_memory" "', argument " "7"" of type '" "unsigned int""'");
3261    }
3262    arg7 = (unsigned int)(val7);
3263    ecode8 = SWIG_AsVal_unsigned_SS_int SWIG_PERL_CALL_ARGS_2(ST(7), &val8);
3264    if (!SWIG_IsOK(ecode8)) {
3265      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "netpgp_sign_memory" "', argument " "8"" of type '" "unsigned int""'");
3266    }
3267    arg8 = (unsigned int)(val8);
3268    result = (int)netpgp_sign_memory(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
3269    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3270
3271    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3272    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3273
3274    if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
3275
3276
3277
3278    XSRETURN(argvi);
3279  fail:
3280
3281    if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3282    if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3283
3284    if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
3285
3286
3287
3288    SWIG_croak_null();
3289  }
3290}
3291
3292
3293XS(_wrap_netpgp_verify_memory) {
3294  {
3295    netpgp_t *arg1 = (netpgp_t *) 0 ;
3296    void *arg2 = (void *) 0 ;
3297    size_t arg3 ;
3298    int arg4 ;
3299    int result;
3300    void *argp1 = 0 ;
3301    int res1 = 0 ;
3302    int res2 ;
3303    size_t val3 ;
3304    int ecode3 = 0 ;
3305    int val4 ;
3306    int ecode4 = 0 ;
3307    int argvi = 0;
3308    dXSARGS;
3309
3310    if ((items < 4) || (items > 4)) {
3311      SWIG_croak("Usage: netpgp_verify_memory(netpgp_t *,void const *,size_t const,int const);");
3312    }
3313    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3314    if (!SWIG_IsOK(res1)) {
3315      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_verify_memory" "', argument " "1"" of type '" "netpgp_t *""'");
3316    }
3317    arg1 = (netpgp_t *)(argp1);
3318    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, 0);
3319    if (!SWIG_IsOK(res2)) {
3320      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_verify_memory" "', argument " "2"" of type '" "void const *""'");
3321    }
3322    ecode3 = SWIG_AsVal_size_t SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
3323    if (!SWIG_IsOK(ecode3)) {
3324      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "netpgp_verify_memory" "', argument " "3"" of type '" "size_t""'");
3325    }
3326    arg3 = (size_t)(val3);
3327    ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
3328    if (!SWIG_IsOK(ecode4)) {
3329      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_verify_memory" "', argument " "4"" of type '" "int""'");
3330    }
3331    arg4 = (int)(val4);
3332    result = (int)netpgp_verify_memory(arg1,(void const *)arg2,arg3,arg4);
3333    ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(result)); argvi++ ;
3334
3335
3336
3337
3338    XSRETURN(argvi);
3339  fail:
3340
3341
3342
3343
3344    SWIG_croak_null();
3345  }
3346}
3347
3348
3349
3350/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3351
3352static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
3353static swig_type_info _swigt__p_netpgp_t = {"_p_netpgp_t", "struct netpgp_t *|netpgp_t *", 0, 0, (void*)"netpgpperl::netpgp_t", 0};
3354static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
3355static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
3356
3357static swig_type_info *swig_type_initial[] = {
3358  &_swigt__p_char,
3359  &_swigt__p_netpgp_t,
3360  &_swigt__p_p_char,
3361  &_swigt__p_void,
3362};
3363
3364static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3365static swig_cast_info _swigc__p_netpgp_t[] = {  {&_swigt__p_netpgp_t, 0, 0, 0},{0, 0, 0, 0}};
3366static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
3367static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
3368
3369static swig_cast_info *swig_cast_initial[] = {
3370  _swigc__p_char,
3371  _swigc__p_netpgp_t,
3372  _swigc__p_p_char,
3373  _swigc__p_void,
3374};
3375
3376
3377/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3378
3379static swig_constant_info swig_constants[] = {
3380{0,0,0,0,0,0}
3381};
3382#ifdef __cplusplus
3383}
3384#endif
3385static swig_variable_info swig_variables[] = {
3386{0,0,0,0}
3387};
3388static swig_command_info swig_commands[] = {
3389{"netpgpperlc::netpgp_t_c_set", _wrap_netpgp_t_c_set},
3390{"netpgpperlc::netpgp_t_c_get", _wrap_netpgp_t_c_get},
3391{"netpgpperlc::netpgp_t_size_set", _wrap_netpgp_t_size_set},
3392{"netpgpperlc::netpgp_t_size_get", _wrap_netpgp_t_size_get},
3393{"netpgpperlc::netpgp_t_name_set", _wrap_netpgp_t_name_set},
3394{"netpgpperlc::netpgp_t_name_get", _wrap_netpgp_t_name_get},
3395{"netpgpperlc::netpgp_t_value_set", _wrap_netpgp_t_value_set},
3396{"netpgpperlc::netpgp_t_value_get", _wrap_netpgp_t_value_get},
3397{"netpgpperlc::netpgp_t_pubring_set", _wrap_netpgp_t_pubring_set},
3398{"netpgpperlc::netpgp_t_pubring_get", _wrap_netpgp_t_pubring_get},
3399{"netpgpperlc::netpgp_t_secring_set", _wrap_netpgp_t_secring_set},
3400{"netpgpperlc::netpgp_t_secring_get", _wrap_netpgp_t_secring_get},
3401{"netpgpperlc::netpgp_t_io_set", _wrap_netpgp_t_io_set},
3402{"netpgpperlc::netpgp_t_io_get", _wrap_netpgp_t_io_get},
3403{"netpgpperlc::netpgp_t_passfp_set", _wrap_netpgp_t_passfp_set},
3404{"netpgpperlc::netpgp_t_passfp_get", _wrap_netpgp_t_passfp_get},
3405{"netpgpperlc::new_netpgp_t", _wrap_new_netpgp_t},
3406{"netpgpperlc::delete_netpgp_t", _wrap_delete_netpgp_t},
3407{"netpgpperlc::netpgp_init", _wrap_netpgp_init},
3408{"netpgpperlc::netpgp_end", _wrap_netpgp_end},
3409{"netpgpperlc::netpgp_set_debug", _wrap_netpgp_set_debug},
3410{"netpgpperlc::netpgp_get_debug", _wrap_netpgp_get_debug},
3411{"netpgpperlc::netpgp_get_info", _wrap_netpgp_get_info},
3412{"netpgpperlc::netpgp_list_packets", _wrap_netpgp_list_packets},
3413{"netpgpperlc::netpgp_setvar", _wrap_netpgp_setvar},
3414{"netpgpperlc::netpgp_getvar", _wrap_netpgp_getvar},
3415{"netpgpperlc::netpgp_list_keys", _wrap_netpgp_list_keys},
3416{"netpgpperlc::netpgp_list_sigs", _wrap_netpgp_list_sigs},
3417{"netpgpperlc::netpgp_find_key", _wrap_netpgp_find_key},
3418{"netpgpperlc::netpgp_get_key", _wrap_netpgp_get_key},
3419{"netpgpperlc::netpgp_export_key", _wrap_netpgp_export_key},
3420{"netpgpperlc::netpgp_import_key", _wrap_netpgp_import_key},
3421{"netpgpperlc::netpgp_generate_key", _wrap_netpgp_generate_key},
3422{"netpgpperlc::netpgp_encrypt_file", _wrap_netpgp_encrypt_file},
3423{"netpgpperlc::netpgp_decrypt_file", _wrap_netpgp_decrypt_file},
3424{"netpgpperlc::netpgp_sign_file", _wrap_netpgp_sign_file},
3425{"netpgpperlc::netpgp_verify_file", _wrap_netpgp_verify_file},
3426{"netpgpperlc::netpgp_sign_memory", _wrap_netpgp_sign_memory},
3427{"netpgpperlc::netpgp_verify_memory", _wrap_netpgp_verify_memory},
3428{0,0}
3429};
3430/* -----------------------------------------------------------------------------
3431 * Type initialization:
3432 * This problem is tough by the requirement that no dynamic
3433 * memory is used. Also, since swig_type_info structures store pointers to
3434 * swig_cast_info structures and swig_cast_info structures store pointers back
3435 * to swig_type_info structures, we need some lookup code at initialization.
3436 * The idea is that swig generates all the structures that are needed.
3437 * The runtime then collects these partially filled structures.
3438 * The SWIG_InitializeModule function takes these initial arrays out of
3439 * swig_module, and does all the lookup, filling in the swig_module.types
3440 * array with the correct data and linking the correct swig_cast_info
3441 * structures together.
3442 *
3443 * The generated swig_type_info structures are assigned staticly to an initial
3444 * array. We just loop through that array, and handle each type individually.
3445 * First we lookup if this type has been already loaded, and if so, use the
3446 * loaded structure instead of the generated one. Then we have to fill in the
3447 * cast linked list. The cast data is initially stored in something like a
3448 * two-dimensional array. Each row corresponds to a type (there are the same
3449 * number of rows as there are in the swig_type_initial array). Each entry in
3450 * a column is one of the swig_cast_info structures for that type.
3451 * The cast_initial array is actually an array of arrays, because each row has
3452 * a variable number of columns. So to actually build the cast linked list,
3453 * we find the array of casts associated with the type, and loop through it
3454 * adding the casts to the list. The one last trick we need to do is making
3455 * sure the type pointer in the swig_cast_info struct is correct.
3456 *
3457 * First off, we lookup the cast->type name to see if it is already loaded.
3458 * There are three cases to handle:
3459 *  1) If the cast->type has already been loaded AND the type we are adding
3460 *     casting info to has not been loaded (it is in this module), THEN we
3461 *     replace the cast->type pointer with the type pointer that has already
3462 *     been loaded.
3463 *  2) If BOTH types (the one we are adding casting info to, and the
3464 *     cast->type) are loaded, THEN the cast info has already been loaded by
3465 *     the previous module so we just ignore it.
3466 *  3) Finally, if cast->type has not already been loaded, then we add that
3467 *     swig_cast_info to the linked list (because the cast->type) pointer will
3468 *     be correct.
3469 * ----------------------------------------------------------------------------- */
3470
3471#ifdef __cplusplus
3472extern "C" {
3473#if 0
3474} /* c-mode */
3475#endif
3476#endif
3477
3478#if 0
3479#define SWIGRUNTIME_DEBUG
3480#endif
3481
3482
3483SWIGRUNTIME void
3484SWIG_InitializeModule(void *clientdata) {
3485  size_t i;
3486  swig_module_info *module_head, *iter;
3487  int found;
3488
3489  clientdata = clientdata;
3490
3491  /* check to see if the circular list has been setup, if not, set it up */
3492  if (swig_module.next==0) {
3493    /* Initialize the swig_module */
3494    swig_module.type_initial = swig_type_initial;
3495    swig_module.cast_initial = swig_cast_initial;
3496    swig_module.next = &swig_module;
3497  }
3498
3499  /* Try and load any already created modules */
3500  module_head = SWIG_GetModule(clientdata);
3501  if (!module_head) {
3502    /* This is the first module loaded for this interpreter */
3503    /* so set the swig module into the interpreter */
3504    SWIG_SetModule(clientdata, &swig_module);
3505    module_head = &swig_module;
3506  } else {
3507    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
3508    found=0;
3509    iter=module_head;
3510    do {
3511      if (iter==&swig_module) {
3512        found=1;
3513        break;
3514      }
3515      iter=iter->next;
3516    } while (iter!= module_head);
3517
3518    /* if the is found in the list, then all is done and we may leave */
3519    if (found) return;
3520    /* otherwise we must add out module into the list */
3521    swig_module.next = module_head->next;
3522    module_head->next = &swig_module;
3523  }
3524
3525  /* Now work on filling in swig_module.types */
3526#ifdef SWIGRUNTIME_DEBUG
3527  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
3528#endif
3529  for (i = 0; i < swig_module.size; ++i) {
3530    swig_type_info *type = 0;
3531    swig_type_info *ret;
3532    swig_cast_info *cast;
3533
3534#ifdef SWIGRUNTIME_DEBUG
3535    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3536#endif
3537
3538    /* if there is another module already loaded */
3539    if (swig_module.next != &swig_module) {
3540      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3541    }
3542    if (type) {
3543      /* Overwrite clientdata field */
3544#ifdef SWIGRUNTIME_DEBUG
3545      printf("SWIG_InitializeModule: found type %s\n", type->name);
3546#endif
3547      if (swig_module.type_initial[i]->clientdata) {
3548        type->clientdata = swig_module.type_initial[i]->clientdata;
3549#ifdef SWIGRUNTIME_DEBUG
3550        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3551#endif
3552      }
3553    } else {
3554      type = swig_module.type_initial[i];
3555    }
3556
3557    /* Insert casting types */
3558    cast = swig_module.cast_initial[i];
3559    while (cast->type) {
3560      /* Don't need to add information already in the list */
3561      ret = 0;
3562#ifdef SWIGRUNTIME_DEBUG
3563      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
3564#endif
3565      if (swig_module.next != &swig_module) {
3566        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
3567#ifdef SWIGRUNTIME_DEBUG
3568        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
3569#endif
3570      }
3571      if (ret) {
3572        if (type == swig_module.type_initial[i]) {
3573#ifdef SWIGRUNTIME_DEBUG
3574          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
3575#endif
3576          cast->type = ret;
3577          ret = 0;
3578        } else {
3579          /* Check for casting already in the list */
3580          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
3581#ifdef SWIGRUNTIME_DEBUG
3582          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
3583#endif
3584          if (!ocast) ret = 0;
3585        }
3586      }
3587
3588      if (!ret) {
3589#ifdef SWIGRUNTIME_DEBUG
3590        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
3591#endif
3592        if (type->cast) {
3593          type->cast->prev = cast;
3594          cast->next = type->cast;
3595        }
3596        type->cast = cast;
3597      }
3598      cast++;
3599    }
3600    /* Set entry in modules->types array equal to the type */
3601    swig_module.types[i] = type;
3602  }
3603  swig_module.types[i] = 0;
3604
3605#ifdef SWIGRUNTIME_DEBUG
3606  printf("**** SWIG_InitializeModule: Cast List ******\n");
3607  for (i = 0; i < swig_module.size; ++i) {
3608    int j = 0;
3609    swig_cast_info *cast = swig_module.cast_initial[i];
3610    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3611    while (cast->type) {
3612      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
3613      cast++;
3614      ++j;
3615    }
3616    printf("---- Total casts: %d\n",j);
3617  }
3618  printf("**** SWIG_InitializeModule: Cast List ******\n");
3619#endif
3620}
3621
3622/* This function will propagate the clientdata field of type to
3623* any new swig_type_info structures that have been added into the list
3624* of equivalent types.  It is like calling
3625* SWIG_TypeClientData(type, clientdata) a second time.
3626*/
3627SWIGRUNTIME void
3628SWIG_PropagateClientData(void) {
3629  size_t i;
3630  swig_cast_info *equiv;
3631  static int init_run = 0;
3632
3633  if (init_run) return;
3634  init_run = 1;
3635
3636  for (i = 0; i < swig_module.size; i++) {
3637    if (swig_module.types[i]->clientdata) {
3638      equiv = swig_module.types[i]->cast;
3639      while (equiv) {
3640        if (!equiv->converter) {
3641          if (equiv->type && !equiv->type->clientdata)
3642          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
3643        }
3644        equiv = equiv->next;
3645      }
3646    }
3647  }
3648}
3649
3650#ifdef __cplusplus
3651#if 0
3652{
3653  /* c-mode */
3654#endif
3655}
3656#endif
3657
3658
3659
3660#ifdef __cplusplus
3661extern "C"
3662#endif
3663
3664XS(SWIG_init) {
3665  dXSARGS;
3666  int i;
3667
3668  SWIG_InitializeModule(0);
3669
3670  /* Install commands */
3671  for (i = 0; swig_commands[i].name; i++) {
3672    newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
3673  }
3674
3675  /* Install variables */
3676  for (i = 0; swig_variables[i].name; i++) {
3677    SV *sv;
3678    sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2);
3679    if (swig_variables[i].type) {
3680      SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
3681    } else {
3682      sv_setiv(sv,(IV) 0);
3683    }
3684    swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
3685  }
3686
3687  /* Install constant */
3688  for (i = 0; swig_constants[i].type; i++) {
3689    SV *sv;
3690    sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2);
3691    switch(swig_constants[i].type) {
3692    case SWIG_INT:
3693      sv_setiv(sv, (IV) swig_constants[i].lvalue);
3694      break;
3695    case SWIG_FLOAT:
3696      sv_setnv(sv, (double) swig_constants[i].dvalue);
3697      break;
3698    case SWIG_STRING:
3699      sv_setpv(sv, (char *) swig_constants[i].pvalue);
3700      break;
3701    case SWIG_POINTER:
3702      SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
3703      break;
3704    case SWIG_BINARY:
3705      SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
3706      break;
3707    default:
3708      break;
3709    }
3710    SvREADONLY_on(sv);
3711  }
3712
3713  SWIG_TypeClientData(SWIGTYPE_p_netpgp_t, (void*) "netpgpperl::netpgp_t");
3714  ST(0) = &PL_sv_yes;
3715  XSRETURN(1);
3716}
3717
3718