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