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