git.gag.com Git - debian/amanda/blob - 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_unlock) {
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_unlock(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_unlock" "', argument " "1"" of type '" "file_lock *""'");
2487     }
2488     arg1 = (file_lock *)(argp1);
2489     result = (int)file_lock_unlock(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_write) {
2508   {
2509     file_lock *arg1 = (file_lock *) 0 ;
2510     char *arg2 = (char *) 0 ;
2511     size_t arg3 ;
2512     void *argp1 = 0 ;
2513     int res1 = 0 ;
2514     int argvi = 0;
2515     int result;
2516     dXSARGS;
2517
2518     if ((items < 2) || (items > 2)) {
2519       SWIG_croak("Usage: file_lock_write(self,data,len);");
2520     }
2521     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_file_lock, 0 |  0 );
2522     if (!SWIG_IsOK(res1)) {
2523       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "file_lock_write" "', argument " "1"" of type '" "file_lock *""'");
2524     }
2525     arg1 = (file_lock *)(argp1);
2526     {
2527       arg2 = SvPV(ST(1), arg3);
2528     }
2529     result = (int)file_lock_write(arg1,(char const *)arg2,arg3);
2530     {
2531       SV *for_stack;
2532       SP += argvi; PUTBACK;
2533       for_stack = sv_2mortal(amglue_newSVi64(result));
2534       SPAGAIN; SP -= argvi;
2535       ST(argvi) = for_stack;
2536       argvi++;
2537     }
2538
2539
2540     XSRETURN(argvi);
2541   fail:
2542
2543
2544     SWIG_croak_null();
2545   }
2546 }
2547
2548
2549 XS(_wrap_file_lock_data) {
2550   {
2551     file_lock *arg1 = (file_lock *) 0 ;
2552     void *argp1 = 0 ;
2553     int res1 = 0 ;
2554     int argvi = 0;
2555     SV *result = 0 ;
2556     dXSARGS;
2557
2558     if ((items < 1) || (items > 1)) {
2559       SWIG_croak("Usage: file_lock_data(self);");
2560     }
2561     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_file_lock, 0 |  0 );
2562     if (!SWIG_IsOK(res1)) {
2563       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "file_lock_data" "', argument " "1"" of type '" "file_lock *""'");
2564     }
2565     arg1 = (file_lock *)(argp1);
2566     result = (SV *)file_lock_data(arg1);
2567     {
2568       ST(argvi) = result; argvi++;
2569     }
2570
2571     XSRETURN(argvi);
2572   fail:
2573
2574     SWIG_croak_null();
2575   }
2576 }
2577
2578
2579 XS(_wrap_delete_file_lock) {
2580   {
2581     file_lock *arg1 = (file_lock *) 0 ;
2582     void *argp1 = 0 ;
2583     int res1 = 0 ;
2584     int argvi = 0;
2585     dXSARGS;
2586
2587     if ((items < 1) || (items > 1)) {
2588       SWIG_croak("Usage: delete_file_lock(self);");
2589     }
2590     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_file_lock, SWIG_POINTER_DISOWN |  0 );
2591     if (!SWIG_IsOK(res1)) {
2592       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_file_lock" "', argument " "1"" of type '" "file_lock *""'");
2593     }
2594     arg1 = (file_lock *)(argp1);
2595     free((char *) arg1);
2596     ST(argvi) = sv_newmortal();
2597
2598     XSRETURN(argvi);
2599   fail:
2600
2601     SWIG_croak_null();
2602   }
2603 }
2604
2605
2606 XS(_wrap_weaken_ref) {
2607   {
2608     SV *arg1 = (SV *) 0 ;
2609     int argvi = 0;
2610     dXSARGS;
2611
2612     if ((items < 1) || (items > 1)) {
2613       SWIG_croak("Usage: weaken_ref(rv);");
2614     }
2615     arg1 = ST(0);
2616     weaken_ref(arg1);
2617     ST(argvi) = sv_newmortal();
2618
2619     XSRETURN(argvi);
2620   fail:
2621
2622     SWIG_croak_null();
2623   }
2624 }
2625
2626
2627 XS(_wrap_gettimeofday) {
2628   {
2629     int argvi = 0;
2630     guint64 result;
2631     dXSARGS;
2632
2633     if ((items < 0) || (items > 0)) {
2634       SWIG_croak("Usage: gettimeofday();");
2635     }
2636     result = gettimeofday_for_perl();
2637     {
2638       SV *for_stack;
2639       SP += argvi; PUTBACK;
2640       for_stack = sv_2mortal(amglue_newSVu64(result));
2641       SPAGAIN; SP -= argvi;
2642       ST(argvi) = for_stack;
2643       argvi++;
2644     }
2645     XSRETURN(argvi);
2646   fail:
2647     SWIG_croak_null();
2648   }
2649 }
2650
2651
2652 XS(_wrap_openbsd_fd_inform) {
2653   {
2654     int argvi = 0;
2655     dXSARGS;
2656
2657     if ((items < 0) || (items > 0)) {
2658       SWIG_croak("Usage: openbsd_fd_inform();");
2659     }
2660     openbsd_fd_inform();
2661     ST(argvi) = sv_newmortal();
2662     XSRETURN(argvi);
2663   fail:
2664     SWIG_croak_null();
2665   }
2666 }
2667
2668
2669 XS(_wrap_stream_server) {
2670   {
2671     int arg1 ;
2672     in_port_t *arg2 = (in_port_t *) 0 ;
2673     size_t arg3 ;
2674     size_t arg4 ;
2675     gboolean arg5 ;
2676     in_port_t port2 ;
2677     int argvi = 0;
2678     socketfd result;
2679     dXSARGS;
2680
2681     {
2682       arg2 = &port2;
2683     }
2684     if ((items < 4) || (items > 4)) {
2685       SWIG_croak("Usage: stream_server(family,sendsize,recvsize,privileged);");
2686     }
2687     {
2688       if (sizeof(signed int) == 1) {
2689         arg1 = amglue_SvI8(ST(0));
2690       } else if (sizeof(signed int) == 2) {
2691         arg1 = amglue_SvI16(ST(0));
2692       } else if (sizeof(signed int) == 4) {
2693         arg1 = amglue_SvI32(ST(0));
2694       } else if (sizeof(signed int) == 8) {
2695         arg1 = amglue_SvI64(ST(0));
2696       } else {
2697         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2698       }
2699     }
2700     {
2701       if (sizeof(size_t) == 1) {
2702         arg3 = amglue_SvU8(ST(1));
2703       } else if (sizeof(size_t) == 2) {
2704         arg3 = amglue_SvU16(ST(1));
2705       } else if (sizeof(size_t) == 4) {
2706         arg3 = amglue_SvU32(ST(1));
2707       } else if (sizeof(size_t) == 8) {
2708         arg3 = amglue_SvU64(ST(1));
2709       } else {
2710         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
2711       }
2712     }
2713     {
2714       if (sizeof(size_t) == 1) {
2715         arg4 = amglue_SvU8(ST(2));
2716       } else if (sizeof(size_t) == 2) {
2717         arg4 = amglue_SvU16(ST(2));
2718       } else if (sizeof(size_t) == 4) {
2719         arg4 = amglue_SvU32(ST(2));
2720       } else if (sizeof(size_t) == 8) {
2721         arg4 = amglue_SvU64(ST(2));
2722       } else {
2723         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
2724       }
2725     }
2726     {
2727       arg5 = SvTRUE(ST(3));
2728     }
2729     result = stream_server(arg1,arg2,arg3,arg4,arg5);
2730     {
2731       ST(argvi) = sv_2mortal(newSViv(result));
2732       argvi++;
2733     }
2734     {
2735       ST(argvi) = sv_2mortal(newSViv(*arg2));
2736       argvi++;
2737     }
2738
2739
2740
2741
2742
2743     XSRETURN(argvi);
2744   fail:
2745
2746
2747
2748
2749
2750     SWIG_croak_null();
2751   }
2752 }
2753
2754
2755 XS(_wrap_stream_accept) {
2756   {
2757     int arg1 ;
2758     int arg2 ;
2759     size_t arg3 ;
2760     size_t arg4 ;
2761     int argvi = 0;
2762     socketfd result;
2763     dXSARGS;
2764
2765     if ((items < 4) || (items > 4)) {
2766       SWIG_croak("Usage: stream_accept(fd,timeout,sendsize,recvsize);");
2767     }
2768     {
2769       IO *io = NULL;
2770       PerlIO *pio = NULL;
2771       int fd = -1;
2772
2773       if (SvIOK(ST(0))) {
2774         /* plain old integer */
2775         arg1 = SvIV(ST(0));
2776       } else {
2777         /* try extracting as filehandle */
2778
2779         /* note: sv_2io may call die() */
2780         io = sv_2io(ST(0));
2781         if (io) {
2782           pio = IoIFP(io);
2783         }
2784         if (pio) {
2785           fd = PerlIO_fileno(pio);
2786         }
2787         if (fd >= 0) {
2788           arg1 = fd;
2789         } else {
2790           SWIG_exception(SWIG_TypeError, "Expected integer file descriptor "
2791             "or file handle for argument 1");
2792         }
2793       }
2794     }
2795     {
2796       if (sizeof(signed int) == 1) {
2797         arg2 = amglue_SvI8(ST(1));
2798       } else if (sizeof(signed int) == 2) {
2799         arg2 = amglue_SvI16(ST(1));
2800       } else if (sizeof(signed int) == 4) {
2801         arg2 = amglue_SvI32(ST(1));
2802       } else if (sizeof(signed int) == 8) {
2803         arg2 = amglue_SvI64(ST(1));
2804       } else {
2805         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2806       }
2807     }
2808     {
2809       if (sizeof(size_t) == 1) {
2810         arg3 = amglue_SvU8(ST(2));
2811       } else if (sizeof(size_t) == 2) {
2812         arg3 = amglue_SvU16(ST(2));
2813       } else if (sizeof(size_t) == 4) {
2814         arg3 = amglue_SvU32(ST(2));
2815       } else if (sizeof(size_t) == 8) {
2816         arg3 = amglue_SvU64(ST(2));
2817       } else {
2818         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
2819       }
2820     }
2821     {
2822       if (sizeof(size_t) == 1) {
2823         arg4 = amglue_SvU8(ST(3));
2824       } else if (sizeof(size_t) == 2) {
2825         arg4 = amglue_SvU16(ST(3));
2826       } else if (sizeof(size_t) == 4) {
2827         arg4 = amglue_SvU32(ST(3));
2828       } else if (sizeof(size_t) == 8) {
2829         arg4 = amglue_SvU64(ST(3));
2830       } else {
2831         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
2832       }
2833     }
2834     result = stream_accept(arg1,arg2,arg3,arg4);
2835     {
2836       ST(argvi) = sv_2mortal(newSViv(result));
2837       argvi++;
2838     }
2839
2840
2841
2842
2843     XSRETURN(argvi);
2844   fail:
2845
2846
2847
2848
2849     SWIG_croak_null();
2850   }
2851 }
2852
2853
2854 XS(_wrap_check_security) {
2855   {
2856     int arg1 ;
2857     char *arg2 = (char *) 0 ;
2858     int res2 ;
2859     char *buf2 = 0 ;
2860     int alloc2 = 0 ;
2861     int argvi = 0;
2862     char *result = 0 ;
2863     dXSARGS;
2864
2865     if ((items < 2) || (items > 2)) {
2866       SWIG_croak("Usage: check_security(fd,userstr);");
2867     }
2868     {
2869       IO *io = NULL;
2870       PerlIO *pio = NULL;
2871       int fd = -1;
2872
2873       if (SvIOK(ST(0))) {
2874         /* plain old integer */
2875         arg1 = SvIV(ST(0));
2876       } else {
2877         /* try extracting as filehandle */
2878
2879         /* note: sv_2io may call die() */
2880         io = sv_2io(ST(0));
2881         if (io) {
2882           pio = IoIFP(io);
2883         }
2884         if (pio) {
2885           fd = PerlIO_fileno(pio);
2886         }
2887         if (fd >= 0) {
2888           arg1 = fd;
2889         } else {
2890           SWIG_exception(SWIG_TypeError, "Expected integer file descriptor "
2891             "or file handle for argument 1");
2892         }
2893       }
2894     }
2895     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2896     if (!SWIG_IsOK(res2)) {
2897       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "check_security" "', argument " "2"" of type '" "char *""'");
2898     }
2899     arg2 = (char *)(buf2);
2900     result = (char *)check_security_fd(arg1,arg2);
2901     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2902
2903     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2904     free((char*)result);
2905     XSRETURN(argvi);
2906   fail:
2907
2908     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2909     SWIG_croak_null();
2910   }
2911 }
2912
2913
2914 XS(_wrap_set_pname) {
2915   {
2916     char *arg1 = (char *) 0 ;
2917     int res1 ;
2918     char *buf1 = 0 ;
2919     int alloc1 = 0 ;
2920     int argvi = 0;
2921     dXSARGS;
2922
2923     if ((items < 1) || (items > 1)) {
2924       SWIG_croak("Usage: set_pname(name);");
2925     }
2926     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2927     if (!SWIG_IsOK(res1)) {
2928       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_pname" "', argument " "1"" of type '" "char *""'");
2929     }
2930     arg1 = (char *)(buf1);
2931     set_pname(arg1);
2932     ST(argvi) = sv_newmortal();
2933     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2934     XSRETURN(argvi);
2935   fail:
2936     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2937     SWIG_croak_null();
2938   }
2939 }
2940
2941
2942 XS(_wrap_get_pname) {
2943   {
2944     int argvi = 0;
2945     char *result = 0 ;
2946     dXSARGS;
2947
2948     if ((items < 0) || (items > 0)) {
2949       SWIG_croak("Usage: get_pname();");
2950     }
2951     result = (char *)get_pname();
2952     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2953     XSRETURN(argvi);
2954   fail:
2955     SWIG_croak_null();
2956   }
2957 }
2958
2959
2960 XS(_wrap_set_ptype) {
2961   {
2962     char *arg1 = (char *) 0 ;
2963     int res1 ;
2964     char *buf1 = 0 ;
2965     int alloc1 = 0 ;
2966     int argvi = 0;
2967     dXSARGS;
2968
2969     if ((items < 1) || (items > 1)) {
2970       SWIG_croak("Usage: set_ptype(type);");
2971     }
2972     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2973     if (!SWIG_IsOK(res1)) {
2974       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_ptype" "', argument " "1"" of type '" "char *""'");
2975     }
2976     arg1 = (char *)(buf1);
2977     set_ptype(arg1);
2978     ST(argvi) = sv_newmortal();
2979     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2980     XSRETURN(argvi);
2981   fail:
2982     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2983     SWIG_croak_null();
2984   }
2985 }
2986
2987
2988 XS(_wrap_get_ptype) {
2989   {
2990     int argvi = 0;
2991     char *result = 0 ;
2992     dXSARGS;
2993
2994     if ((items < 0) || (items > 0)) {
2995       SWIG_croak("Usage: get_ptype();");
2996     }
2997     result = (char *)get_ptype();
2998     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2999     XSRETURN(argvi);
3000   fail:
3001     SWIG_croak_null();
3002   }
3003 }
3004
3005
3006 XS(_wrap_set_pcontext) {
3007   {
3008     pcontext_t arg1 ;
3009     int argvi = 0;
3010     dXSARGS;
3011
3012     if ((items < 1) || (items > 1)) {
3013       SWIG_croak("Usage: set_pcontext(context);");
3014     }
3015     {
3016       if (sizeof(signed int) == 1) {
3017         arg1 = amglue_SvI8(ST(0));
3018       } else if (sizeof(signed int) == 2) {
3019         arg1 = amglue_SvI16(ST(0));
3020       } else if (sizeof(signed int) == 4) {
3021         arg1 = amglue_SvI32(ST(0));
3022       } else if (sizeof(signed int) == 8) {
3023         arg1 = amglue_SvI64(ST(0));
3024       } else {
3025         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3026       }
3027     }
3028     set_pcontext(arg1);
3029     ST(argvi) = sv_newmortal();
3030
3031     XSRETURN(argvi);
3032   fail:
3033
3034     SWIG_croak_null();
3035   }
3036 }
3037
3038
3039 XS(_wrap_get_pcontext) {
3040   {
3041     int argvi = 0;
3042     pcontext_t result;
3043     dXSARGS;
3044
3045     if ((items < 0) || (items > 0)) {
3046       SWIG_croak("Usage: get_pcontext();");
3047     }
3048     result = (pcontext_t)get_pcontext();
3049     {
3050       SV *for_stack;
3051       SP += argvi; PUTBACK;
3052       for_stack = sv_2mortal(amglue_newSVi64(result));
3053       SPAGAIN; SP -= argvi;
3054       ST(argvi) = for_stack;
3055       argvi++;
3056     }
3057     XSRETURN(argvi);
3058   fail:
3059     SWIG_croak_null();
3060   }
3061 }
3062
3063
3064 XS(_wrap_safe_cd) {
3065   {
3066     int argvi = 0;
3067     dXSARGS;
3068
3069     if ((items < 0) || (items > 0)) {
3070       SWIG_croak("Usage: safe_cd();");
3071     }
3072     safe_cd();
3073     ST(argvi) = sv_newmortal();
3074     XSRETURN(argvi);
3075   fail:
3076     SWIG_croak_null();
3077   }
3078 }
3079
3080
3081 XS(_wrap_check_running_as) {
3082   {
3083     running_as_flags arg1 ;
3084     int argvi = 0;
3085     dXSARGS;
3086
3087     if ((items < 1) || (items > 1)) {
3088       SWIG_croak("Usage: check_running_as(who);");
3089     }
3090     {
3091       if (sizeof(signed int) == 1) {
3092         arg1 = amglue_SvI8(ST(0));
3093       } else if (sizeof(signed int) == 2) {
3094         arg1 = amglue_SvI16(ST(0));
3095       } else if (sizeof(signed int) == 4) {
3096         arg1 = amglue_SvI32(ST(0));
3097       } else if (sizeof(signed int) == 8) {
3098         arg1 = amglue_SvI64(ST(0));
3099       } else {
3100         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3101       }
3102     }
3103     check_running_as(arg1);
3104     ST(argvi) = sv_newmortal();
3105
3106     XSRETURN(argvi);
3107   fail:
3108
3109     SWIG_croak_null();
3110   }
3111 }
3112
3113
3114
3115 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3116
3117 static swig_type_info _swigt__p_GPtrArray = {"_p_GPtrArray", "GPtrArray *", 0, 0, (void*)0, 0};
3118 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
3119 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
3120 static swig_type_info _swigt__p_file_lock = {"_p_file_lock", "struct file_lock *|file_lock *", 0, 0, (void*)"Amanda::Util::file_lock", 0};
3121 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
3122 static swig_type_info _swigt__p_fs_usage = {"_p_fs_usage", "struct fs_usage *", 0, 0, (void*)0, 0};
3123 static swig_type_info _swigt__p_in_port_t = {"_p_in_port_t", "in_port_t *", 0, 0, (void*)0, 0};
3124 static swig_type_info _swigt__p_int = {"_p_int", "int *|pcontext_t *|gboolean *|running_as_flags *", 0, 0, (void*)0, 0};
3125 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
3126
3127 static swig_type_info *swig_type_initial[] = {
3128   &_swigt__p_GPtrArray,
3129   &_swigt__p_char,
3130   &_swigt__p_double,
3131   &_swigt__p_file_lock,
3132   &_swigt__p_float,
3133   &_swigt__p_fs_usage,
3134   &_swigt__p_in_port_t,
3135   &_swigt__p_int,
3136   &_swigt__p_unsigned_char,
3137 };
3138
3139 static swig_cast_info _swigc__p_GPtrArray[] = {  {&_swigt__p_GPtrArray, 0, 0, 0},{0, 0, 0, 0}};
3140 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3141 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
3142 static swig_cast_info _swigc__p_file_lock[] = {  {&_swigt__p_file_lock, 0, 0, 0},{0, 0, 0, 0}};
3143 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
3144 static swig_cast_info _swigc__p_fs_usage[] = {  {&_swigt__p_fs_usage, 0, 0, 0},{0, 0, 0, 0}};
3145 static swig_cast_info _swigc__p_in_port_t[] = {  {&_swigt__p_in_port_t, 0, 0, 0},{0, 0, 0, 0}};
3146 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
3147 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
3148
3149 static swig_cast_info *swig_cast_initial[] = {
3150   _swigc__p_GPtrArray,
3151   _swigc__p_char,
3152   _swigc__p_double,
3153   _swigc__p_file_lock,
3154   _swigc__p_float,
3155   _swigc__p_fs_usage,
3156   _swigc__p_in_port_t,
3157   _swigc__p_int,
3158   _swigc__p_unsigned_char,
3159 };
3160
3161
3162 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3163
3164 static swig_constant_info swig_constants[] = {
3165 {0,0,0,0,0,0}
3166 };
3167 #ifdef __cplusplus
3168 }
3169 #endif
3170 static swig_variable_info swig_variables[] = {
3171 {0,0,0,0}
3172 };
3173 static swig_command_info swig_commands[] = {
3174 {"Amanda::Utilc::get_original_cwd", _wrap_get_original_cwd},
3175 {"Amanda::Utilc::hexencode", _wrap_hexencode},
3176 {"Amanda::Utilc::hexdecode", _wrap_hexdecode},
3177 {"Amanda::Utilc::sanitise_filename", _wrap_sanitise_filename},
3178 {"Amanda::Utilc::quote_string", _wrap_quote_string},
3179 {"Amanda::Utilc::unquote_string", _wrap_unquote_string},
3180 {"Amanda::Utilc::expand_braced_alternates", _wrap_expand_braced_alternates},
3181 {"Amanda::Utilc::collapse_braced_alternates", _wrap_collapse_braced_alternates},
3182 {"Amanda::Utilc::split_quoted_strings", _wrap_split_quoted_strings},
3183 {"Amanda::Utilc::get_fs_usage", _wrap_get_fs_usage},
3184 {"Amanda::Utilc::fsync", _wrap_fsync},
3185 {"Amanda::Utilc::set_blocking", _wrap_set_blocking},
3186 {"Amanda::Utilc::new_file_lock", _wrap_new_file_lock},
3187 {"Amanda::Utilc::file_lock_lock", _wrap_file_lock_lock},
3188 {"Amanda::Utilc::file_lock_unlock", _wrap_file_lock_unlock},
3189 {"Amanda::Utilc::file_lock_write", _wrap_file_lock_write},
3190 {"Amanda::Utilc::file_lock_data", _wrap_file_lock_data},
3191 {"Amanda::Utilc::delete_file_lock", _wrap_delete_file_lock},
3192 {"Amanda::Utilc::weaken_ref", _wrap_weaken_ref},
3193 {"Amanda::Utilc::gettimeofday", _wrap_gettimeofday},
3194 {"Amanda::Utilc::openbsd_fd_inform", _wrap_openbsd_fd_inform},
3195 {"Amanda::Utilc::stream_server", _wrap_stream_server},
3196 {"Amanda::Utilc::stream_accept", _wrap_stream_accept},
3197 {"Amanda::Utilc::check_security", _wrap_check_security},
3198 {"Amanda::Utilc::set_pname", _wrap_set_pname},
3199 {"Amanda::Utilc::get_pname", _wrap_get_pname},
3200 {"Amanda::Utilc::set_ptype", _wrap_set_ptype},
3201 {"Amanda::Utilc::get_ptype", _wrap_get_ptype},
3202 {"Amanda::Utilc::set_pcontext", _wrap_set_pcontext},
3203 {"Amanda::Utilc::get_pcontext", _wrap_get_pcontext},
3204 {"Amanda::Utilc::safe_cd", _wrap_safe_cd},
3205 {"Amanda::Utilc::check_running_as", _wrap_check_running_as},
3206 {0,0}
3207 };
3208 /* -----------------------------------------------------------------------------
3209  * Type initialization:
3210  * This problem is tough by the requirement that no dynamic
3211  * memory is used. Also, since swig_type_info structures store pointers to
3212  * swig_cast_info structures and swig_cast_info structures store pointers back
3213  * to swig_type_info structures, we need some lookup code at initialization.
3214  * The idea is that swig generates all the structures that are needed.
3215  * The runtime then collects these partially filled structures.
3216  * The SWIG_InitializeModule function takes these initial arrays out of
3217  * swig_module, and does all the lookup, filling in the swig_module.types
3218  * array with the correct data and linking the correct swig_cast_info
3219  * structures together.
3220  *
3221  * The generated swig_type_info structures are assigned staticly to an initial
3222  * array. We just loop through that array, and handle each type individually.
3223  * First we lookup if this type has been already loaded, and if so, use the
3224  * loaded structure instead of the generated one. Then we have to fill in the
3225  * cast linked list. The cast data is initially stored in something like a
3226  * two-dimensional array. Each row corresponds to a type (there are the same
3227  * number of rows as there are in the swig_type_initial array). Each entry in
3228  * a column is one of the swig_cast_info structures for that type.
3229  * The cast_initial array is actually an array of arrays, because each row has
3230  * a variable number of columns. So to actually build the cast linked list,
3231  * we find the array of casts associated with the type, and loop through it
3232  * adding the casts to the list. The one last trick we need to do is making
3233  * sure the type pointer in the swig_cast_info struct is correct.
3234  *
3235  * First off, we lookup the cast->type name to see if it is already loaded.
3236  * There are three cases to handle:
3237  *  1) If the cast->type has already been loaded AND the type we are adding
3238  *     casting info to has not been loaded (it is in this module), THEN we
3239  *     replace the cast->type pointer with the type pointer that has already
3240  *     been loaded.
3241  *  2) If BOTH types (the one we are adding casting info to, and the
3242  *     cast->type) are loaded, THEN the cast info has already been loaded by
3243  *     the previous module so we just ignore it.
3244  *  3) Finally, if cast->type has not already been loaded, then we add that
3245  *     swig_cast_info to the linked list (because the cast->type) pointer will
3246  *     be correct.
3247  * ----------------------------------------------------------------------------- */
3248
3249 #ifdef __cplusplus
3250 extern "C" {
3251 #if 0
3252 } /* c-mode */
3253 #endif
3254 #endif
3255
3256 #if 0
3257 #define SWIGRUNTIME_DEBUG
3258 #endif
3259
3260
3261 SWIGRUNTIME void
3262 SWIG_InitializeModule(void *clientdata) {
3263   size_t i;
3264   swig_module_info *module_head, *iter;
3265   int found, init;
3266
3267   clientdata = clientdata;
3268
3269   /* check to see if the circular list has been setup, if not, set it up */
3270   if (swig_module.next==0) {
3271     /* Initialize the swig_module */
3272     swig_module.type_initial = swig_type_initial;
3273     swig_module.cast_initial = swig_cast_initial;
3274     swig_module.next = &swig_module;
3275     init = 1;
3276   } else {
3277     init = 0;
3278   }
3279
3280   /* Try and load any already created modules */
3281   module_head = SWIG_GetModule(clientdata);
3282   if (!module_head) {
3283     /* This is the first module loaded for this interpreter */
3284     /* so set the swig module into the interpreter */
3285     SWIG_SetModule(clientdata, &swig_module);
3286     module_head = &swig_module;
3287   } else {
3288     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
3289     found=0;
3290     iter=module_head;
3291     do {
3292       if (iter==&swig_module) {
3293         found=1;
3294         break;
3295       }
3296       iter=iter->next;
3297     } while (iter!= module_head);
3298
3299     /* if the is found in the list, then all is done and we may leave */
3300     if (found) return;
3301     /* otherwise we must add out module into the list */
3302     swig_module.next = module_head->next;
3303     module_head->next = &swig_module;
3304   }
3305
3306   /* When multiple interpeters are used, a module could have already been initialized in
3307        a different interpreter, but not yet have a pointer in this interpreter.
3308        In this case, we do not want to continue adding types... everything should be
3309        set up already */
3310   if (init == 0) return;
3311
3312   /* Now work on filling in swig_module.types */
3313 #ifdef SWIGRUNTIME_DEBUG
3314   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
3315 #endif
3316   for (i = 0; i < swig_module.size; ++i) {
3317     swig_type_info *type = 0;
3318     swig_type_info *ret;
3319     swig_cast_info *cast;
3320
3321 #ifdef SWIGRUNTIME_DEBUG
3322     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3323 #endif
3324
3325     /* if there is another module already loaded */
3326     if (swig_module.next != &swig_module) {
3327       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3328     }
3329     if (type) {
3330       /* Overwrite clientdata field */
3331 #ifdef SWIGRUNTIME_DEBUG
3332       printf("SWIG_InitializeModule: found type %s\n", type->name);
3333 #endif
3334       if (swig_module.type_initial[i]->clientdata) {
3335         type->clientdata = swig_module.type_initial[i]->clientdata;
3336 #ifdef SWIGRUNTIME_DEBUG
3337         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3338 #endif
3339       }
3340     } else {
3341       type = swig_module.type_initial[i];
3342     }
3343
3344     /* Insert casting types */
3345     cast = swig_module.cast_initial[i];
3346     while (cast->type) {
3347       /* Don't need to add information already in the list */
3348       ret = 0;
3349 #ifdef SWIGRUNTIME_DEBUG
3350       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
3351 #endif
3352       if (swig_module.next != &swig_module) {
3353         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
3354 #ifdef SWIGRUNTIME_DEBUG
3355         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
3356 #endif
3357       }
3358       if (ret) {
3359         if (type == swig_module.type_initial[i]) {
3360 #ifdef SWIGRUNTIME_DEBUG
3361           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
3362 #endif
3363           cast->type = ret;
3364           ret = 0;
3365         } else {
3366           /* Check for casting already in the list */
3367           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
3368 #ifdef SWIGRUNTIME_DEBUG
3369           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
3370 #endif
3371           if (!ocast) ret = 0;
3372         }
3373       }
3374
3375       if (!ret) {
3376 #ifdef SWIGRUNTIME_DEBUG
3377         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
3378 #endif
3379         if (type->cast) {
3380           type->cast->prev = cast;
3381           cast->next = type->cast;
3382         }
3383         type->cast = cast;
3384       }
3385       cast++;
3386     }
3387     /* Set entry in modules->types array equal to the type */
3388     swig_module.types[i] = type;
3389   }
3390   swig_module.types[i] = 0;
3391
3392 #ifdef SWIGRUNTIME_DEBUG
3393   printf("**** SWIG_InitializeModule: Cast List ******\n");
3394   for (i = 0; i < swig_module.size; ++i) {
3395     int j = 0;
3396     swig_cast_info *cast = swig_module.cast_initial[i];
3397     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3398     while (cast->type) {
3399       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
3400       cast++;
3401       ++j;
3402     }
3403     printf("---- Total casts: %d\n",j);
3404   }
3405   printf("**** SWIG_InitializeModule: Cast List ******\n");
3406 #endif
3407 }
3408
3409 /* This function will propagate the clientdata field of type to
3410 * any new swig_type_info structures that have been added into the list
3411 * of equivalent types.  It is like calling
3412 * SWIG_TypeClientData(type, clientdata) a second time.
3413 */
3414 SWIGRUNTIME void
3415 SWIG_PropagateClientData(void) {
3416   size_t i;
3417   swig_cast_info *equiv;
3418   static int init_run = 0;
3419
3420   if (init_run) return;
3421   init_run = 1;
3422
3423   for (i = 0; i < swig_module.size; i++) {
3424     if (swig_module.types[i]->clientdata) {
3425       equiv = swig_module.types[i]->cast;
3426       while (equiv) {
3427         if (!equiv->converter) {
3428           if (equiv->type && !equiv->type->clientdata)
3429           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
3430         }
3431         equiv = equiv->next;
3432       }
3433     }
3434   }
3435 }
3436
3437 #ifdef __cplusplus
3438 #if 0
3439 {
3440   /* c-mode */
3441 #endif
3442 }
3443 #endif
3444
3445
3446
3447 #ifdef __cplusplus
3448 extern "C"
3449 #endif
3450
3451 XS(SWIG_init) {
3452   dXSARGS;
3453   int i;
3454
3455   SWIG_InitializeModule(0);
3456
3457   /* Install commands */
3458   for (i = 0; swig_commands[i].name; i++) {
3459     newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
3460   }
3461
3462   /* Install variables */
3463   for (i = 0; swig_variables[i].name; i++) {
3464     SV *sv;
3465     sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
3466     if (swig_variables[i].type) {
3467       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
3468     } else {
3469       sv_setiv(sv,(IV) 0);
3470     }
3471     swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
3472   }
3473
3474   /* Install constant */
3475   for (i = 0; swig_constants[i].type; i++) {
3476     SV *sv;
3477     sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
3478     switch(swig_constants[i].type) {
3479     case SWIG_INT:
3480       sv_setiv(sv, (IV) swig_constants[i].lvalue);
3481       break;
3482     case SWIG_FLOAT:
3483       sv_setnv(sv, (double) swig_constants[i].dvalue);
3484       break;
3485     case SWIG_STRING:
3486       sv_setpv(sv, (char *) swig_constants[i].pvalue);
3487       break;
3488     case SWIG_POINTER:
3489       SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
3490       break;
3491     case SWIG_BINARY:
3492       SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
3493       break;
3494     default:
3495       break;
3496     }
3497     SvREADONLY_on(sv);
3498   }
3499
3500   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3501     SV *sv = get_sv((char*) SWIG_prefix "RUNNING_AS_ANY", TRUE | 0x2 | GV_ADDMULTI);
3502     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(RUNNING_AS_ANY)));
3503     SvREADONLY_on(sv);
3504   } while(0) /*@SWIG@*/;
3505   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3506     SV *sv = get_sv((char*) SWIG_prefix "RUNNING_AS_ROOT", TRUE | 0x2 | GV_ADDMULTI);
3507     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(RUNNING_AS_ROOT)));
3508     SvREADONLY_on(sv);
3509   } while(0) /*@SWIG@*/;
3510   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3511     SV *sv = get_sv((char*) SWIG_prefix "RUNNING_AS_DUMPUSER", TRUE | 0x2 | GV_ADDMULTI);
3512     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(RUNNING_AS_DUMPUSER)));
3513     SvREADONLY_on(sv);
3514   } while(0) /*@SWIG@*/;
3515   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3516     SV *sv = get_sv((char*) SWIG_prefix "RUNNING_AS_DUMPUSER_PREFERRED", TRUE | 0x2 | GV_ADDMULTI);
3517     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(RUNNING_AS_DUMPUSER_PREFERRED)));
3518     SvREADONLY_on(sv);
3519   } while(0) /*@SWIG@*/;
3520   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3521     SV *sv = get_sv((char*) SWIG_prefix "RUNNING_AS_CLIENT_LOGIN", TRUE | 0x2 | GV_ADDMULTI);
3522     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(RUNNING_AS_CLIENT_LOGIN)));
3523     SvREADONLY_on(sv);
3524   } while(0) /*@SWIG@*/;
3525   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3526     SV *sv = get_sv((char*) SWIG_prefix "RUNNING_AS_UID_ONLY", TRUE | 0x2 | GV_ADDMULTI);
3527     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(RUNNING_AS_UID_ONLY)));
3528     SvREADONLY_on(sv);
3529   } while(0) /*@SWIG@*/;
3530   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3531     SV *sv = get_sv((char*) SWIG_prefix "CONTEXT_DEFAULT", TRUE | 0x2 | GV_ADDMULTI);
3532     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONTEXT_DEFAULT)));
3533     SvREADONLY_on(sv);
3534   } while(0) /*@SWIG@*/;
3535   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3536     SV *sv = get_sv((char*) SWIG_prefix "CONTEXT_CMDLINE", TRUE | 0x2 | GV_ADDMULTI);
3537     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONTEXT_CMDLINE)));
3538     SvREADONLY_on(sv);
3539   } while(0) /*@SWIG@*/;
3540   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3541     SV *sv = get_sv((char*) SWIG_prefix "CONTEXT_DAEMON", TRUE | 0x2 | GV_ADDMULTI);
3542     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONTEXT_DAEMON)));
3543     SvREADONLY_on(sv);
3544   } while(0) /*@SWIG@*/;
3545   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3546     SV *sv = get_sv((char*) SWIG_prefix "CONTEXT_SCRIPTUTIL", TRUE | 0x2 | GV_ADDMULTI);
3547     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONTEXT_SCRIPTUTIL)));
3548     SvREADONLY_on(sv);
3549   } while(0) /*@SWIG@*/;
3550   SWIG_TypeClientData(SWIGTYPE_p_file_lock, (void*) "Amanda::Util::file_lock");
3551   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3552     SV *sv = get_sv((char*) SWIG_prefix "AF_INET", TRUE | 0x2 | GV_ADDMULTI);
3553     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(AF_INET)));
3554     SvREADONLY_on(sv);
3555   } while(0) /*@SWIG@*/;
3556   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3557     SV *sv = get_sv((char*) SWIG_prefix "STREAM_BUFSIZE", TRUE | 0x2 | GV_ADDMULTI);
3558     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(STREAM_BUFSIZE)));
3559     SvREADONLY_on(sv);
3560   } while(0) /*@SWIG@*/;
3561   ST(0) = &PL_sv_yes;
3562   XSRETURN(1);
3563 }
3564