git.gag.com Git - debian/amanda/blob - perl/Amanda/Types.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_a_STRMAX__char swig_types[0]
1478 #define SWIGTYPE_p_char swig_types[1]
1479 #define SWIGTYPE_p_double swig_types[2]
1480 #define SWIGTYPE_p_dumpfile_t swig_types[3]
1481 #define SWIGTYPE_p_float swig_types[4]
1482 #define SWIGTYPE_p_int swig_types[5]
1483 #define SWIGTYPE_p_unsigned_char swig_types[6]
1484 static swig_type_info *swig_types[8];
1485 static swig_module_info swig_module = {swig_types, 7, 0, 0, 0, 0};
1486 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1487 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1488
1489 /* -------- TYPES TABLE (END) -------- */
1490
1491 #define SWIG_init    boot_Amanda__Types
1492
1493 #define SWIG_name   "Amanda::Typesc::boot_Amanda__Types"
1494 #define SWIG_prefix "Amanda::Typesc::"
1495
1496 #define SWIGVERSION 0x010339
1497 #define SWIG_VERSION SWIGVERSION
1498
1499
1500 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1501 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1502
1503
1504 #ifdef __cplusplus
1505 extern "C"
1506 #endif
1507 #ifndef PERL_OBJECT
1508 #ifndef MULTIPLICITY
1509 SWIGEXPORT void SWIG_init (CV* cv);
1510 #else
1511 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1512 #endif
1513 #else
1514 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1515 #endif
1516
1517
1518 #include "amglue.h"
1519
1520
1521 #include "amglue.h"
1522
1523
1524 #include "amglue.h"
1525
1526
1527 #include "fileheader.h"
1528
1529
1530 SWIGINTERNINLINE SV *
1531 SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
1532 {
1533   SV *obj = sv_newmortal();
1534   sv_setiv(obj, (IV) value);
1535   return obj;
1536 }
1537
1538
1539 SWIGINTERNINLINE SV *
1540 SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
1541 {
1542   return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
1543 }
1544
1545
1546 #include <limits.h>
1547 #if !defined(SWIG_NO_LLONG_MAX)
1548 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1549 #   define LLONG_MAX __LONG_LONG_MAX__
1550 #   define LLONG_MIN (-LLONG_MAX - 1LL)
1551 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1552 # endif
1553 #endif
1554
1555
1556 SWIGINTERN int
1557 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1558 {
1559   if (SvNIOK(obj)) {
1560     if (val) *val = SvNV(obj);
1561     return SWIG_OK;
1562   } else if (SvIOK(obj)) {
1563     if (val) *val = (double) SvIV(obj);
1564     return SWIG_AddCast(SWIG_OK);
1565   } else {
1566     const char *nptr = SvPV_nolen(obj);
1567     if (nptr) {
1568       char *endptr;
1569       double v = strtod(nptr, &endptr);
1570       if (errno == ERANGE) {
1571         errno = 0;
1572         return SWIG_OverflowError;
1573       } else {
1574         if (*endptr == '\0') {
1575           if (val) *val = v;
1576           return SWIG_Str2NumCast(SWIG_OK);
1577         }
1578       }
1579     }
1580   }
1581   return SWIG_TypeError;
1582 }
1583
1584
1585 #include <float.h>
1586
1587
1588 #include <math.h>
1589
1590
1591 SWIGINTERNINLINE int
1592 SWIG_CanCastAsInteger(double *d, double min, double max) {
1593   double x = *d;
1594   if ((min <= x && x <= max)) {
1595    double fx = floor(x);
1596    double cx = ceil(x);
1597    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1598    if ((errno == EDOM) || (errno == ERANGE)) {
1599      errno = 0;
1600    } else {
1601      double summ, reps, diff;
1602      if (rd < x) {
1603        diff = x - rd;
1604      } else if (rd > x) {
1605        diff = rd - x;
1606      } else {
1607        return 1;
1608      }
1609      summ = rd + x;
1610      reps = diff/summ;
1611      if (reps < 8*DBL_EPSILON) {
1612        *d = rd;
1613        return 1;
1614      }
1615    }
1616   }
1617   return 0;
1618 }
1619
1620
1621 SWIGINTERN int
1622 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1623 {
1624   if (SvIOK(obj)) {
1625     if (val) *val = SvIV(obj);
1626     return SWIG_OK;
1627   } else {
1628     int dispatch = 0;
1629     const char *nptr = SvPV_nolen(obj);
1630     if (nptr) {
1631       char *endptr;
1632       long v;
1633       errno = 0;
1634       v = strtol(nptr, &endptr,0);
1635       if (errno == ERANGE) {
1636         errno = 0;
1637         return SWIG_OverflowError;
1638       } else {
1639         if (*endptr == '\0') {
1640           if (val) *val = v;
1641           return SWIG_Str2NumCast(SWIG_OK);
1642         }
1643       }
1644     }
1645     if (!dispatch) {
1646       double d;
1647       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1648       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1649         if (val) *val = (long)(d);
1650         return res;
1651       }
1652     }
1653   }
1654   return SWIG_TypeError;
1655 }
1656
1657
1658 SWIGINTERN int
1659 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1660 {
1661   long v;
1662   int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1663   if (SWIG_IsOK(res)) {
1664     if ((v < INT_MIN || v > INT_MAX)) {
1665       return SWIG_OverflowError;
1666     } else {
1667       if (val) *val = (int)(v);
1668     }
1669   }
1670   return res;
1671 }
1672
1673
1674 SWIGINTERN swig_type_info*
1675 SWIG_pchar_descriptor(void)
1676 {
1677   static int init = 0;
1678   static swig_type_info* info = 0;
1679   if (!init) {
1680     info = SWIG_TypeQuery("_p_char");
1681     init = 1;
1682   }
1683   return info;
1684 }
1685
1686
1687 SWIGINTERN int
1688 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1689 {
1690   if (SvMAGICAL(obj)) {
1691      SV *tmp = sv_newmortal();
1692      SvSetSV(tmp, obj);
1693      obj = tmp;
1694   }
1695   if (SvPOK(obj)) {
1696     STRLEN len = 0;
1697     char *cstr = SvPV(obj, len);
1698     size_t size = len + 1;
1699     if (cptr)  {
1700       if (alloc) {
1701         if (*alloc == SWIG_NEWOBJ) {
1702           *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1703         } else {
1704           *cptr = cstr;
1705           *alloc = SWIG_OLDOBJ;
1706         }
1707       }
1708     }
1709     if (psize) *psize = size;
1710     return SWIG_OK;
1711   } else {
1712     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1713     if (pchar_descriptor) {
1714       char* vptr = 0;
1715       if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1716         if (cptr) *cptr = vptr;
1717         if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1718         if (alloc) *alloc = SWIG_OLDOBJ;
1719         return SWIG_OK;
1720       }
1721     }
1722   }
1723   return SWIG_TypeError;
1724 }
1725
1726
1727 SWIGINTERN int
1728 SWIG_AsCharArray(SV * obj, char *val, size_t size)
1729 {
1730   char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
1731   int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
1732   if (SWIG_IsOK(res)) {
1733     if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
1734     if (csize <= size) {
1735       if (val) {
1736         if (csize) memcpy(val, cptr, csize*sizeof(char));
1737         if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
1738       }
1739       if (alloc == SWIG_NEWOBJ) {
1740         free((char*)cptr);
1741         res = SWIG_DelNewMask(res);
1742       }
1743       return res;
1744     }
1745     if (alloc == SWIG_NEWOBJ) free((char*)cptr);
1746   }
1747   return SWIG_TypeError;
1748 }
1749
1750
1751 SWIGINTERNINLINE SV *
1752 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1753 {
1754   SV *obj = sv_newmortal();
1755   if (carray) {
1756     sv_setpvn(obj, carray, size);
1757   } else {
1758     sv_setsv(obj, &PL_sv_undef);
1759   }
1760   return obj;
1761 }
1762
1763
1764
1765
1766
1767 SWIGINTERNINLINE SV *
1768 SWIG_FromCharPtr(const char *cptr)
1769 {
1770   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1771 }
1772
1773
1774 SWIGINTERN int
1775 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
1776 {
1777   if (SvUOK(obj)) {
1778     if (val) *val = SvUV(obj);
1779     return SWIG_OK;
1780   } else  if (SvIOK(obj)) {
1781     long v = SvIV(obj);
1782     if (v >= 0) {
1783       if (val) *val = v;
1784       return SWIG_OK;
1785     } else {
1786       return SWIG_OverflowError;
1787     }
1788   } else {
1789     int dispatch = 0;
1790     const char *nptr = SvPV_nolen(obj);
1791     if (nptr) {
1792       char *endptr;
1793       unsigned long v;
1794       errno = 0;
1795       v = strtoul(nptr, &endptr,0);
1796       if (errno == ERANGE) {
1797         errno = 0;
1798         return SWIG_OverflowError;
1799       } else {
1800         if (*endptr == '\0') {
1801           if (val) *val = v;
1802           return SWIG_Str2NumCast(SWIG_OK);
1803         }
1804       }
1805     }
1806     if (!dispatch) {
1807       double d;
1808       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1809       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
1810         if (val) *val = (unsigned long)(d);
1811         return res;
1812       }
1813     }
1814   }
1815   return SWIG_TypeError;
1816 }
1817
1818
1819 SWIGINTERNINLINE int
1820 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
1821 {
1822   unsigned long v;
1823   int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
1824   if (SWIG_IsOK(res) && val) *val = (size_t)(v);
1825   return res;
1826 }
1827
1828 SWIGINTERN dumpfile_t *new_dumpfile_t(){
1829             dumpfile_t *df = malloc(sizeof(*df));
1830             fh_init(df);
1831             return df;
1832         }
1833 #ifdef __cplusplus
1834 extern "C" {
1835 #endif
1836
1837 #ifdef PERL_OBJECT
1838 #define MAGIC_CLASS _wrap_Amanda__Types_var::
1839 class _wrap_Amanda__Types_var : public CPerlObj {
1840 public:
1841 #else
1842 #define MAGIC_CLASS
1843 #endif
1844 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
1845     MAGIC_PPERL
1846     croak("Value is read-only.");
1847     return 0;
1848 }
1849
1850
1851 #ifdef PERL_OBJECT
1852 };
1853 #endif
1854
1855 #ifdef __cplusplus
1856 }
1857 #endif
1858
1859 #ifdef __cplusplus
1860 extern "C" {
1861 #endif
1862 XS(_wrap_dumpfile_t_type_set) {
1863   {
1864     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1865     filetype_t arg2 ;
1866     void *argp1 = 0 ;
1867     int res1 = 0 ;
1868     int argvi = 0;
1869     dXSARGS;
1870
1871     if ((items < 2) || (items > 2)) {
1872       SWIG_croak("Usage: dumpfile_t_type_set(self,type);");
1873     }
1874     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
1875     if (!SWIG_IsOK(res1)) {
1876       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_type_set" "', argument " "1"" of type '" "dumpfile_t *""'");
1877     }
1878     arg1 = (dumpfile_t *)(argp1);
1879     {
1880       if (sizeof(signed int) == 1) {
1881         arg2 = amglue_SvI8(ST(1));
1882       } else if (sizeof(signed int) == 2) {
1883         arg2 = amglue_SvI16(ST(1));
1884       } else if (sizeof(signed int) == 4) {
1885         arg2 = amglue_SvI32(ST(1));
1886       } else if (sizeof(signed int) == 8) {
1887         arg2 = amglue_SvI64(ST(1));
1888       } else {
1889         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
1890       }
1891     }
1892     if (arg1) (arg1)->type = arg2;
1893     ST(argvi) = sv_newmortal();
1894
1895
1896     XSRETURN(argvi);
1897   fail:
1898
1899
1900     SWIG_croak_null();
1901   }
1902 }
1903
1904
1905 XS(_wrap_dumpfile_t_type_get) {
1906   {
1907     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1908     void *argp1 = 0 ;
1909     int res1 = 0 ;
1910     int argvi = 0;
1911     filetype_t result;
1912     dXSARGS;
1913
1914     if ((items < 1) || (items > 1)) {
1915       SWIG_croak("Usage: dumpfile_t_type_get(self);");
1916     }
1917     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
1918     if (!SWIG_IsOK(res1)) {
1919       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_type_get" "', argument " "1"" of type '" "dumpfile_t *""'");
1920     }
1921     arg1 = (dumpfile_t *)(argp1);
1922     result = (filetype_t) ((arg1)->type);
1923     {
1924       ST(argvi) = sv_2mortal(amglue_newSVi64(result));
1925       argvi++;
1926     }
1927
1928     XSRETURN(argvi);
1929   fail:
1930
1931     SWIG_croak_null();
1932   }
1933 }
1934
1935
1936 XS(_wrap_dumpfile_t_datestamp_set) {
1937   {
1938     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1939     char *arg2 ;
1940     void *argp1 = 0 ;
1941     int res1 = 0 ;
1942     char temp2[STRMAX] ;
1943     int res2 ;
1944     int argvi = 0;
1945     dXSARGS;
1946
1947     if ((items < 2) || (items > 2)) {
1948       SWIG_croak("Usage: dumpfile_t_datestamp_set(self,datestamp);");
1949     }
1950     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
1951     if (!SWIG_IsOK(res1)) {
1952       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_datestamp_set" "', argument " "1"" of type '" "dumpfile_t *""'");
1953     }
1954     arg1 = (dumpfile_t *)(argp1);
1955     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
1956     if (!SWIG_IsOK(res2)) {
1957       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_datestamp_set" "', argument " "2"" of type '" "char [STRMAX]""'");
1958     }
1959     arg2 = (char *)(temp2);
1960     {
1961       strncpy(arg1->datestamp, arg2, STRMAX);
1962       if (arg1->datestamp[STRMAX-1] != '\0')
1963       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
1964     }
1965     ST(argvi) = sv_newmortal();
1966
1967
1968     XSRETURN(argvi);
1969   fail:
1970
1971
1972     SWIG_croak_null();
1973   }
1974 }
1975
1976
1977 XS(_wrap_dumpfile_t_datestamp_get) {
1978   {
1979     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1980     void *argp1 = 0 ;
1981     int res1 = 0 ;
1982     int argvi = 0;
1983     char *result = 0 ;
1984     dXSARGS;
1985
1986     if ((items < 1) || (items > 1)) {
1987       SWIG_croak("Usage: dumpfile_t_datestamp_get(self);");
1988     }
1989     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
1990     if (!SWIG_IsOK(res1)) {
1991       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_datestamp_get" "', argument " "1"" of type '" "dumpfile_t *""'");
1992     }
1993     arg1 = (dumpfile_t *)(argp1);
1994     result = (char *) ((arg1)->datestamp);
1995     {
1996       size_t size = STRMAX;
1997
1998       while (size && (result[size - 1] == '\0')) --size;
1999
2000       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2001     }
2002
2003     XSRETURN(argvi);
2004   fail:
2005
2006     SWIG_croak_null();
2007   }
2008 }
2009
2010
2011 XS(_wrap_dumpfile_t_dumplevel_set) {
2012   {
2013     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2014     int arg2 ;
2015     void *argp1 = 0 ;
2016     int res1 = 0 ;
2017     int argvi = 0;
2018     dXSARGS;
2019
2020     if ((items < 2) || (items > 2)) {
2021       SWIG_croak("Usage: dumpfile_t_dumplevel_set(self,dumplevel);");
2022     }
2023     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2024     if (!SWIG_IsOK(res1)) {
2025       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_dumplevel_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2026     }
2027     arg1 = (dumpfile_t *)(argp1);
2028     {
2029       if (sizeof(signed int) == 1) {
2030         arg2 = amglue_SvI8(ST(1));
2031       } else if (sizeof(signed int) == 2) {
2032         arg2 = amglue_SvI16(ST(1));
2033       } else if (sizeof(signed int) == 4) {
2034         arg2 = amglue_SvI32(ST(1));
2035       } else if (sizeof(signed int) == 8) {
2036         arg2 = amglue_SvI64(ST(1));
2037       } else {
2038         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2039       }
2040     }
2041     if (arg1) (arg1)->dumplevel = arg2;
2042     ST(argvi) = sv_newmortal();
2043
2044
2045     XSRETURN(argvi);
2046   fail:
2047
2048
2049     SWIG_croak_null();
2050   }
2051 }
2052
2053
2054 XS(_wrap_dumpfile_t_dumplevel_get) {
2055   {
2056     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2057     void *argp1 = 0 ;
2058     int res1 = 0 ;
2059     int argvi = 0;
2060     int result;
2061     dXSARGS;
2062
2063     if ((items < 1) || (items > 1)) {
2064       SWIG_croak("Usage: dumpfile_t_dumplevel_get(self);");
2065     }
2066     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2067     if (!SWIG_IsOK(res1)) {
2068       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_dumplevel_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2069     }
2070     arg1 = (dumpfile_t *)(argp1);
2071     result = (int) ((arg1)->dumplevel);
2072     {
2073       ST(argvi) = sv_2mortal(amglue_newSVi64(result));
2074       argvi++;
2075     }
2076
2077     XSRETURN(argvi);
2078   fail:
2079
2080     SWIG_croak_null();
2081   }
2082 }
2083
2084
2085 XS(_wrap_dumpfile_t_compressed_set) {
2086   {
2087     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2088     int arg2 ;
2089     void *argp1 = 0 ;
2090     int res1 = 0 ;
2091     int argvi = 0;
2092     dXSARGS;
2093
2094     if ((items < 2) || (items > 2)) {
2095       SWIG_croak("Usage: dumpfile_t_compressed_set(self,compressed);");
2096     }
2097     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2098     if (!SWIG_IsOK(res1)) {
2099       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_compressed_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2100     }
2101     arg1 = (dumpfile_t *)(argp1);
2102     {
2103       if (sizeof(signed int) == 1) {
2104         arg2 = amglue_SvI8(ST(1));
2105       } else if (sizeof(signed int) == 2) {
2106         arg2 = amglue_SvI16(ST(1));
2107       } else if (sizeof(signed int) == 4) {
2108         arg2 = amglue_SvI32(ST(1));
2109       } else if (sizeof(signed int) == 8) {
2110         arg2 = amglue_SvI64(ST(1));
2111       } else {
2112         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2113       }
2114     }
2115     if (arg1) (arg1)->compressed = arg2;
2116     ST(argvi) = sv_newmortal();
2117
2118
2119     XSRETURN(argvi);
2120   fail:
2121
2122
2123     SWIG_croak_null();
2124   }
2125 }
2126
2127
2128 XS(_wrap_dumpfile_t_compressed_get) {
2129   {
2130     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2131     void *argp1 = 0 ;
2132     int res1 = 0 ;
2133     int argvi = 0;
2134     int result;
2135     dXSARGS;
2136
2137     if ((items < 1) || (items > 1)) {
2138       SWIG_croak("Usage: dumpfile_t_compressed_get(self);");
2139     }
2140     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2141     if (!SWIG_IsOK(res1)) {
2142       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_compressed_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2143     }
2144     arg1 = (dumpfile_t *)(argp1);
2145     result = (int) ((arg1)->compressed);
2146     {
2147       ST(argvi) = sv_2mortal(amglue_newSVi64(result));
2148       argvi++;
2149     }
2150
2151     XSRETURN(argvi);
2152   fail:
2153
2154     SWIG_croak_null();
2155   }
2156 }
2157
2158
2159 XS(_wrap_dumpfile_t_encrypted_set) {
2160   {
2161     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2162     int arg2 ;
2163     void *argp1 = 0 ;
2164     int res1 = 0 ;
2165     int argvi = 0;
2166     dXSARGS;
2167
2168     if ((items < 2) || (items > 2)) {
2169       SWIG_croak("Usage: dumpfile_t_encrypted_set(self,encrypted);");
2170     }
2171     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2172     if (!SWIG_IsOK(res1)) {
2173       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_encrypted_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2174     }
2175     arg1 = (dumpfile_t *)(argp1);
2176     {
2177       if (sizeof(signed int) == 1) {
2178         arg2 = amglue_SvI8(ST(1));
2179       } else if (sizeof(signed int) == 2) {
2180         arg2 = amglue_SvI16(ST(1));
2181       } else if (sizeof(signed int) == 4) {
2182         arg2 = amglue_SvI32(ST(1));
2183       } else if (sizeof(signed int) == 8) {
2184         arg2 = amglue_SvI64(ST(1));
2185       } else {
2186         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2187       }
2188     }
2189     if (arg1) (arg1)->encrypted = arg2;
2190     ST(argvi) = sv_newmortal();
2191
2192
2193     XSRETURN(argvi);
2194   fail:
2195
2196
2197     SWIG_croak_null();
2198   }
2199 }
2200
2201
2202 XS(_wrap_dumpfile_t_encrypted_get) {
2203   {
2204     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2205     void *argp1 = 0 ;
2206     int res1 = 0 ;
2207     int argvi = 0;
2208     int result;
2209     dXSARGS;
2210
2211     if ((items < 1) || (items > 1)) {
2212       SWIG_croak("Usage: dumpfile_t_encrypted_get(self);");
2213     }
2214     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2215     if (!SWIG_IsOK(res1)) {
2216       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_encrypted_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2217     }
2218     arg1 = (dumpfile_t *)(argp1);
2219     result = (int) ((arg1)->encrypted);
2220     {
2221       ST(argvi) = sv_2mortal(amglue_newSVi64(result));
2222       argvi++;
2223     }
2224
2225     XSRETURN(argvi);
2226   fail:
2227
2228     SWIG_croak_null();
2229   }
2230 }
2231
2232
2233 XS(_wrap_dumpfile_t_comp_suffix_set) {
2234   {
2235     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2236     char *arg2 ;
2237     void *argp1 = 0 ;
2238     int res1 = 0 ;
2239     char temp2[STRMAX] ;
2240     int res2 ;
2241     int argvi = 0;
2242     dXSARGS;
2243
2244     if ((items < 2) || (items > 2)) {
2245       SWIG_croak("Usage: dumpfile_t_comp_suffix_set(self,comp_suffix);");
2246     }
2247     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2248     if (!SWIG_IsOK(res1)) {
2249       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_comp_suffix_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2250     }
2251     arg1 = (dumpfile_t *)(argp1);
2252     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2253     if (!SWIG_IsOK(res2)) {
2254       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_comp_suffix_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2255     }
2256     arg2 = (char *)(temp2);
2257     {
2258       strncpy(arg1->comp_suffix, arg2, STRMAX);
2259       if (arg1->comp_suffix[STRMAX-1] != '\0')
2260       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
2261     }
2262     ST(argvi) = sv_newmortal();
2263
2264
2265     XSRETURN(argvi);
2266   fail:
2267
2268
2269     SWIG_croak_null();
2270   }
2271 }
2272
2273
2274 XS(_wrap_dumpfile_t_comp_suffix_get) {
2275   {
2276     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2277     void *argp1 = 0 ;
2278     int res1 = 0 ;
2279     int argvi = 0;
2280     char *result = 0 ;
2281     dXSARGS;
2282
2283     if ((items < 1) || (items > 1)) {
2284       SWIG_croak("Usage: dumpfile_t_comp_suffix_get(self);");
2285     }
2286     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2287     if (!SWIG_IsOK(res1)) {
2288       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_comp_suffix_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2289     }
2290     arg1 = (dumpfile_t *)(argp1);
2291     result = (char *) ((arg1)->comp_suffix);
2292     {
2293       size_t size = STRMAX;
2294
2295       while (size && (result[size - 1] == '\0')) --size;
2296
2297       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2298     }
2299
2300     XSRETURN(argvi);
2301   fail:
2302
2303     SWIG_croak_null();
2304   }
2305 }
2306
2307
2308 XS(_wrap_dumpfile_t_encrypt_suffix_set) {
2309   {
2310     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2311     char *arg2 ;
2312     void *argp1 = 0 ;
2313     int res1 = 0 ;
2314     char temp2[STRMAX] ;
2315     int res2 ;
2316     int argvi = 0;
2317     dXSARGS;
2318
2319     if ((items < 2) || (items > 2)) {
2320       SWIG_croak("Usage: dumpfile_t_encrypt_suffix_set(self,encrypt_suffix);");
2321     }
2322     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2323     if (!SWIG_IsOK(res1)) {
2324       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_encrypt_suffix_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2325     }
2326     arg1 = (dumpfile_t *)(argp1);
2327     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2328     if (!SWIG_IsOK(res2)) {
2329       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_encrypt_suffix_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2330     }
2331     arg2 = (char *)(temp2);
2332     {
2333       strncpy(arg1->encrypt_suffix, arg2, STRMAX);
2334       if (arg1->encrypt_suffix[STRMAX-1] != '\0')
2335       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
2336     }
2337     ST(argvi) = sv_newmortal();
2338
2339
2340     XSRETURN(argvi);
2341   fail:
2342
2343
2344     SWIG_croak_null();
2345   }
2346 }
2347
2348
2349 XS(_wrap_dumpfile_t_encrypt_suffix_get) {
2350   {
2351     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2352     void *argp1 = 0 ;
2353     int res1 = 0 ;
2354     int argvi = 0;
2355     char *result = 0 ;
2356     dXSARGS;
2357
2358     if ((items < 1) || (items > 1)) {
2359       SWIG_croak("Usage: dumpfile_t_encrypt_suffix_get(self);");
2360     }
2361     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2362     if (!SWIG_IsOK(res1)) {
2363       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_encrypt_suffix_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2364     }
2365     arg1 = (dumpfile_t *)(argp1);
2366     result = (char *) ((arg1)->encrypt_suffix);
2367     {
2368       size_t size = STRMAX;
2369
2370       while (size && (result[size - 1] == '\0')) --size;
2371
2372       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2373     }
2374
2375     XSRETURN(argvi);
2376   fail:
2377
2378     SWIG_croak_null();
2379   }
2380 }
2381
2382
2383 XS(_wrap_dumpfile_t_name_set) {
2384   {
2385     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2386     char *arg2 ;
2387     void *argp1 = 0 ;
2388     int res1 = 0 ;
2389     char temp2[STRMAX] ;
2390     int res2 ;
2391     int argvi = 0;
2392     dXSARGS;
2393
2394     if ((items < 2) || (items > 2)) {
2395       SWIG_croak("Usage: dumpfile_t_name_set(self,name);");
2396     }
2397     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2398     if (!SWIG_IsOK(res1)) {
2399       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_name_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2400     }
2401     arg1 = (dumpfile_t *)(argp1);
2402     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2403     if (!SWIG_IsOK(res2)) {
2404       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_name_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2405     }
2406     arg2 = (char *)(temp2);
2407     {
2408       strncpy(arg1->name, arg2, STRMAX);
2409       if (arg1->name[STRMAX-1] != '\0')
2410       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
2411     }
2412     ST(argvi) = sv_newmortal();
2413
2414
2415     XSRETURN(argvi);
2416   fail:
2417
2418
2419     SWIG_croak_null();
2420   }
2421 }
2422
2423
2424 XS(_wrap_dumpfile_t_name_get) {
2425   {
2426     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2427     void *argp1 = 0 ;
2428     int res1 = 0 ;
2429     int argvi = 0;
2430     char *result = 0 ;
2431     dXSARGS;
2432
2433     if ((items < 1) || (items > 1)) {
2434       SWIG_croak("Usage: dumpfile_t_name_get(self);");
2435     }
2436     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2437     if (!SWIG_IsOK(res1)) {
2438       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_name_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2439     }
2440     arg1 = (dumpfile_t *)(argp1);
2441     result = (char *) ((arg1)->name);
2442     {
2443       size_t size = STRMAX;
2444
2445       while (size && (result[size - 1] == '\0')) --size;
2446
2447       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2448     }
2449
2450     XSRETURN(argvi);
2451   fail:
2452
2453     SWIG_croak_null();
2454   }
2455 }
2456
2457
2458 XS(_wrap_dumpfile_t_disk_set) {
2459   {
2460     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2461     char *arg2 ;
2462     void *argp1 = 0 ;
2463     int res1 = 0 ;
2464     char temp2[STRMAX] ;
2465     int res2 ;
2466     int argvi = 0;
2467     dXSARGS;
2468
2469     if ((items < 2) || (items > 2)) {
2470       SWIG_croak("Usage: dumpfile_t_disk_set(self,disk);");
2471     }
2472     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2473     if (!SWIG_IsOK(res1)) {
2474       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_disk_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2475     }
2476     arg1 = (dumpfile_t *)(argp1);
2477     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2478     if (!SWIG_IsOK(res2)) {
2479       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_disk_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2480     }
2481     arg2 = (char *)(temp2);
2482     {
2483       strncpy(arg1->disk, arg2, STRMAX);
2484       if (arg1->disk[STRMAX-1] != '\0')
2485       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
2486     }
2487     ST(argvi) = sv_newmortal();
2488
2489
2490     XSRETURN(argvi);
2491   fail:
2492
2493
2494     SWIG_croak_null();
2495   }
2496 }
2497
2498
2499 XS(_wrap_dumpfile_t_disk_get) {
2500   {
2501     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2502     void *argp1 = 0 ;
2503     int res1 = 0 ;
2504     int argvi = 0;
2505     char *result = 0 ;
2506     dXSARGS;
2507
2508     if ((items < 1) || (items > 1)) {
2509       SWIG_croak("Usage: dumpfile_t_disk_get(self);");
2510     }
2511     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2512     if (!SWIG_IsOK(res1)) {
2513       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_disk_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2514     }
2515     arg1 = (dumpfile_t *)(argp1);
2516     result = (char *) ((arg1)->disk);
2517     {
2518       size_t size = STRMAX;
2519
2520       while (size && (result[size - 1] == '\0')) --size;
2521
2522       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2523     }
2524
2525     XSRETURN(argvi);
2526   fail:
2527
2528     SWIG_croak_null();
2529   }
2530 }
2531
2532
2533 XS(_wrap_dumpfile_t_program_set) {
2534   {
2535     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2536     char *arg2 ;
2537     void *argp1 = 0 ;
2538     int res1 = 0 ;
2539     char temp2[STRMAX] ;
2540     int res2 ;
2541     int argvi = 0;
2542     dXSARGS;
2543
2544     if ((items < 2) || (items > 2)) {
2545       SWIG_croak("Usage: dumpfile_t_program_set(self,program);");
2546     }
2547     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2548     if (!SWIG_IsOK(res1)) {
2549       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_program_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2550     }
2551     arg1 = (dumpfile_t *)(argp1);
2552     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2553     if (!SWIG_IsOK(res2)) {
2554       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_program_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2555     }
2556     arg2 = (char *)(temp2);
2557     {
2558       strncpy(arg1->program, arg2, STRMAX);
2559       if (arg1->program[STRMAX-1] != '\0')
2560       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
2561     }
2562     ST(argvi) = sv_newmortal();
2563
2564
2565     XSRETURN(argvi);
2566   fail:
2567
2568
2569     SWIG_croak_null();
2570   }
2571 }
2572
2573
2574 XS(_wrap_dumpfile_t_program_get) {
2575   {
2576     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2577     void *argp1 = 0 ;
2578     int res1 = 0 ;
2579     int argvi = 0;
2580     char *result = 0 ;
2581     dXSARGS;
2582
2583     if ((items < 1) || (items > 1)) {
2584       SWIG_croak("Usage: dumpfile_t_program_get(self);");
2585     }
2586     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2587     if (!SWIG_IsOK(res1)) {
2588       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_program_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2589     }
2590     arg1 = (dumpfile_t *)(argp1);
2591     result = (char *) ((arg1)->program);
2592     {
2593       size_t size = STRMAX;
2594
2595       while (size && (result[size - 1] == '\0')) --size;
2596
2597       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2598     }
2599
2600     XSRETURN(argvi);
2601   fail:
2602
2603     SWIG_croak_null();
2604   }
2605 }
2606
2607
2608 XS(_wrap_dumpfile_t_application_set) {
2609   {
2610     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2611     char *arg2 ;
2612     void *argp1 = 0 ;
2613     int res1 = 0 ;
2614     char temp2[STRMAX] ;
2615     int res2 ;
2616     int argvi = 0;
2617     dXSARGS;
2618
2619     if ((items < 2) || (items > 2)) {
2620       SWIG_croak("Usage: dumpfile_t_application_set(self,application);");
2621     }
2622     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2623     if (!SWIG_IsOK(res1)) {
2624       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_application_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2625     }
2626     arg1 = (dumpfile_t *)(argp1);
2627     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2628     if (!SWIG_IsOK(res2)) {
2629       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_application_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2630     }
2631     arg2 = (char *)(temp2);
2632     {
2633       strncpy(arg1->application, arg2, STRMAX);
2634       if (arg1->application[STRMAX-1] != '\0')
2635       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
2636     }
2637     ST(argvi) = sv_newmortal();
2638
2639
2640     XSRETURN(argvi);
2641   fail:
2642
2643
2644     SWIG_croak_null();
2645   }
2646 }
2647
2648
2649 XS(_wrap_dumpfile_t_application_get) {
2650   {
2651     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2652     void *argp1 = 0 ;
2653     int res1 = 0 ;
2654     int argvi = 0;
2655     char *result = 0 ;
2656     dXSARGS;
2657
2658     if ((items < 1) || (items > 1)) {
2659       SWIG_croak("Usage: dumpfile_t_application_get(self);");
2660     }
2661     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2662     if (!SWIG_IsOK(res1)) {
2663       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_application_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2664     }
2665     arg1 = (dumpfile_t *)(argp1);
2666     result = (char *) ((arg1)->application);
2667     {
2668       size_t size = STRMAX;
2669
2670       while (size && (result[size - 1] == '\0')) --size;
2671
2672       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2673     }
2674
2675     XSRETURN(argvi);
2676   fail:
2677
2678     SWIG_croak_null();
2679   }
2680 }
2681
2682
2683 XS(_wrap_dumpfile_t_srvcompprog_set) {
2684   {
2685     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2686     char *arg2 ;
2687     void *argp1 = 0 ;
2688     int res1 = 0 ;
2689     char temp2[STRMAX] ;
2690     int res2 ;
2691     int argvi = 0;
2692     dXSARGS;
2693
2694     if ((items < 2) || (items > 2)) {
2695       SWIG_croak("Usage: dumpfile_t_srvcompprog_set(self,srvcompprog);");
2696     }
2697     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2698     if (!SWIG_IsOK(res1)) {
2699       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_srvcompprog_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2700     }
2701     arg1 = (dumpfile_t *)(argp1);
2702     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2703     if (!SWIG_IsOK(res2)) {
2704       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_srvcompprog_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2705     }
2706     arg2 = (char *)(temp2);
2707     {
2708       strncpy(arg1->srvcompprog, arg2, STRMAX);
2709       if (arg1->srvcompprog[STRMAX-1] != '\0')
2710       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
2711     }
2712     ST(argvi) = sv_newmortal();
2713
2714
2715     XSRETURN(argvi);
2716   fail:
2717
2718
2719     SWIG_croak_null();
2720   }
2721 }
2722
2723
2724 XS(_wrap_dumpfile_t_srvcompprog_get) {
2725   {
2726     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2727     void *argp1 = 0 ;
2728     int res1 = 0 ;
2729     int argvi = 0;
2730     char *result = 0 ;
2731     dXSARGS;
2732
2733     if ((items < 1) || (items > 1)) {
2734       SWIG_croak("Usage: dumpfile_t_srvcompprog_get(self);");
2735     }
2736     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2737     if (!SWIG_IsOK(res1)) {
2738       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_srvcompprog_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2739     }
2740     arg1 = (dumpfile_t *)(argp1);
2741     result = (char *) ((arg1)->srvcompprog);
2742     {
2743       size_t size = STRMAX;
2744
2745       while (size && (result[size - 1] == '\0')) --size;
2746
2747       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2748     }
2749
2750     XSRETURN(argvi);
2751   fail:
2752
2753     SWIG_croak_null();
2754   }
2755 }
2756
2757
2758 XS(_wrap_dumpfile_t_clntcompprog_set) {
2759   {
2760     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2761     char *arg2 ;
2762     void *argp1 = 0 ;
2763     int res1 = 0 ;
2764     char temp2[STRMAX] ;
2765     int res2 ;
2766     int argvi = 0;
2767     dXSARGS;
2768
2769     if ((items < 2) || (items > 2)) {
2770       SWIG_croak("Usage: dumpfile_t_clntcompprog_set(self,clntcompprog);");
2771     }
2772     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2773     if (!SWIG_IsOK(res1)) {
2774       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_clntcompprog_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2775     }
2776     arg1 = (dumpfile_t *)(argp1);
2777     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2778     if (!SWIG_IsOK(res2)) {
2779       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_clntcompprog_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2780     }
2781     arg2 = (char *)(temp2);
2782     {
2783       strncpy(arg1->clntcompprog, arg2, STRMAX);
2784       if (arg1->clntcompprog[STRMAX-1] != '\0')
2785       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
2786     }
2787     ST(argvi) = sv_newmortal();
2788
2789
2790     XSRETURN(argvi);
2791   fail:
2792
2793
2794     SWIG_croak_null();
2795   }
2796 }
2797
2798
2799 XS(_wrap_dumpfile_t_clntcompprog_get) {
2800   {
2801     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2802     void *argp1 = 0 ;
2803     int res1 = 0 ;
2804     int argvi = 0;
2805     char *result = 0 ;
2806     dXSARGS;
2807
2808     if ((items < 1) || (items > 1)) {
2809       SWIG_croak("Usage: dumpfile_t_clntcompprog_get(self);");
2810     }
2811     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2812     if (!SWIG_IsOK(res1)) {
2813       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_clntcompprog_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2814     }
2815     arg1 = (dumpfile_t *)(argp1);
2816     result = (char *) ((arg1)->clntcompprog);
2817     {
2818       size_t size = STRMAX;
2819
2820       while (size && (result[size - 1] == '\0')) --size;
2821
2822       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2823     }
2824
2825     XSRETURN(argvi);
2826   fail:
2827
2828     SWIG_croak_null();
2829   }
2830 }
2831
2832
2833 XS(_wrap_dumpfile_t_srv_encrypt_set) {
2834   {
2835     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2836     char *arg2 ;
2837     void *argp1 = 0 ;
2838     int res1 = 0 ;
2839     char temp2[STRMAX] ;
2840     int res2 ;
2841     int argvi = 0;
2842     dXSARGS;
2843
2844     if ((items < 2) || (items > 2)) {
2845       SWIG_croak("Usage: dumpfile_t_srv_encrypt_set(self,srv_encrypt);");
2846     }
2847     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2848     if (!SWIG_IsOK(res1)) {
2849       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_srv_encrypt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2850     }
2851     arg1 = (dumpfile_t *)(argp1);
2852     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2853     if (!SWIG_IsOK(res2)) {
2854       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_srv_encrypt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2855     }
2856     arg2 = (char *)(temp2);
2857     {
2858       strncpy(arg1->srv_encrypt, arg2, STRMAX);
2859       if (arg1->srv_encrypt[STRMAX-1] != '\0')
2860       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
2861     }
2862     ST(argvi) = sv_newmortal();
2863
2864
2865     XSRETURN(argvi);
2866   fail:
2867
2868
2869     SWIG_croak_null();
2870   }
2871 }
2872
2873
2874 XS(_wrap_dumpfile_t_srv_encrypt_get) {
2875   {
2876     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2877     void *argp1 = 0 ;
2878     int res1 = 0 ;
2879     int argvi = 0;
2880     char *result = 0 ;
2881     dXSARGS;
2882
2883     if ((items < 1) || (items > 1)) {
2884       SWIG_croak("Usage: dumpfile_t_srv_encrypt_get(self);");
2885     }
2886     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2887     if (!SWIG_IsOK(res1)) {
2888       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_srv_encrypt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2889     }
2890     arg1 = (dumpfile_t *)(argp1);
2891     result = (char *) ((arg1)->srv_encrypt);
2892     {
2893       size_t size = STRMAX;
2894
2895       while (size && (result[size - 1] == '\0')) --size;
2896
2897       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2898     }
2899
2900     XSRETURN(argvi);
2901   fail:
2902
2903     SWIG_croak_null();
2904   }
2905 }
2906
2907
2908 XS(_wrap_dumpfile_t_clnt_encrypt_set) {
2909   {
2910     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2911     char *arg2 ;
2912     void *argp1 = 0 ;
2913     int res1 = 0 ;
2914     char temp2[STRMAX] ;
2915     int res2 ;
2916     int argvi = 0;
2917     dXSARGS;
2918
2919     if ((items < 2) || (items > 2)) {
2920       SWIG_croak("Usage: dumpfile_t_clnt_encrypt_set(self,clnt_encrypt);");
2921     }
2922     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2923     if (!SWIG_IsOK(res1)) {
2924       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_clnt_encrypt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2925     }
2926     arg1 = (dumpfile_t *)(argp1);
2927     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2928     if (!SWIG_IsOK(res2)) {
2929       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_clnt_encrypt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2930     }
2931     arg2 = (char *)(temp2);
2932     {
2933       strncpy(arg1->clnt_encrypt, arg2, STRMAX);
2934       if (arg1->clnt_encrypt[STRMAX-1] != '\0')
2935       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
2936     }
2937     ST(argvi) = sv_newmortal();
2938
2939
2940     XSRETURN(argvi);
2941   fail:
2942
2943
2944     SWIG_croak_null();
2945   }
2946 }
2947
2948
2949 XS(_wrap_dumpfile_t_clnt_encrypt_get) {
2950   {
2951     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2952     void *argp1 = 0 ;
2953     int res1 = 0 ;
2954     int argvi = 0;
2955     char *result = 0 ;
2956     dXSARGS;
2957
2958     if ((items < 1) || (items > 1)) {
2959       SWIG_croak("Usage: dumpfile_t_clnt_encrypt_get(self);");
2960     }
2961     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2962     if (!SWIG_IsOK(res1)) {
2963       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_clnt_encrypt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2964     }
2965     arg1 = (dumpfile_t *)(argp1);
2966     result = (char *) ((arg1)->clnt_encrypt);
2967     {
2968       size_t size = STRMAX;
2969
2970       while (size && (result[size - 1] == '\0')) --size;
2971
2972       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2973     }
2974
2975     XSRETURN(argvi);
2976   fail:
2977
2978     SWIG_croak_null();
2979   }
2980 }
2981
2982
2983 XS(_wrap_dumpfile_t_recover_cmd_set) {
2984   {
2985     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2986     char *arg2 ;
2987     void *argp1 = 0 ;
2988     int res1 = 0 ;
2989     char temp2[STRMAX] ;
2990     int res2 ;
2991     int argvi = 0;
2992     dXSARGS;
2993
2994     if ((items < 2) || (items > 2)) {
2995       SWIG_croak("Usage: dumpfile_t_recover_cmd_set(self,recover_cmd);");
2996     }
2997     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2998     if (!SWIG_IsOK(res1)) {
2999       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_recover_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3000     }
3001     arg1 = (dumpfile_t *)(argp1);
3002     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3003     if (!SWIG_IsOK(res2)) {
3004       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_recover_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3005     }
3006     arg2 = (char *)(temp2);
3007     {
3008       strncpy(arg1->recover_cmd, arg2, STRMAX);
3009       if (arg1->recover_cmd[STRMAX-1] != '\0')
3010       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
3011     }
3012     ST(argvi) = sv_newmortal();
3013
3014
3015     XSRETURN(argvi);
3016   fail:
3017
3018
3019     SWIG_croak_null();
3020   }
3021 }
3022
3023
3024 XS(_wrap_dumpfile_t_recover_cmd_get) {
3025   {
3026     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3027     void *argp1 = 0 ;
3028     int res1 = 0 ;
3029     int argvi = 0;
3030     char *result = 0 ;
3031     dXSARGS;
3032
3033     if ((items < 1) || (items > 1)) {
3034       SWIG_croak("Usage: dumpfile_t_recover_cmd_get(self);");
3035     }
3036     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3037     if (!SWIG_IsOK(res1)) {
3038       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_recover_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3039     }
3040     arg1 = (dumpfile_t *)(argp1);
3041     result = (char *) ((arg1)->recover_cmd);
3042     {
3043       size_t size = STRMAX;
3044
3045       while (size && (result[size - 1] == '\0')) --size;
3046
3047       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3048     }
3049
3050     XSRETURN(argvi);
3051   fail:
3052
3053     SWIG_croak_null();
3054   }
3055 }
3056
3057
3058 XS(_wrap_dumpfile_t_uncompress_cmd_set) {
3059   {
3060     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3061     char *arg2 ;
3062     void *argp1 = 0 ;
3063     int res1 = 0 ;
3064     char temp2[STRMAX] ;
3065     int res2 ;
3066     int argvi = 0;
3067     dXSARGS;
3068
3069     if ((items < 2) || (items > 2)) {
3070       SWIG_croak("Usage: dumpfile_t_uncompress_cmd_set(self,uncompress_cmd);");
3071     }
3072     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3073     if (!SWIG_IsOK(res1)) {
3074       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_uncompress_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3075     }
3076     arg1 = (dumpfile_t *)(argp1);
3077     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3078     if (!SWIG_IsOK(res2)) {
3079       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_uncompress_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3080     }
3081     arg2 = (char *)(temp2);
3082     {
3083       strncpy(arg1->uncompress_cmd, arg2, STRMAX);
3084       if (arg1->uncompress_cmd[STRMAX-1] != '\0')
3085       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
3086     }
3087     ST(argvi) = sv_newmortal();
3088
3089
3090     XSRETURN(argvi);
3091   fail:
3092
3093
3094     SWIG_croak_null();
3095   }
3096 }
3097
3098
3099 XS(_wrap_dumpfile_t_uncompress_cmd_get) {
3100   {
3101     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3102     void *argp1 = 0 ;
3103     int res1 = 0 ;
3104     int argvi = 0;
3105     char *result = 0 ;
3106     dXSARGS;
3107
3108     if ((items < 1) || (items > 1)) {
3109       SWIG_croak("Usage: dumpfile_t_uncompress_cmd_get(self);");
3110     }
3111     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3112     if (!SWIG_IsOK(res1)) {
3113       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_uncompress_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3114     }
3115     arg1 = (dumpfile_t *)(argp1);
3116     result = (char *) ((arg1)->uncompress_cmd);
3117     {
3118       size_t size = STRMAX;
3119
3120       while (size && (result[size - 1] == '\0')) --size;
3121
3122       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3123     }
3124
3125     XSRETURN(argvi);
3126   fail:
3127
3128     SWIG_croak_null();
3129   }
3130 }
3131
3132
3133 XS(_wrap_dumpfile_t_encrypt_cmd_set) {
3134   {
3135     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3136     char *arg2 ;
3137     void *argp1 = 0 ;
3138     int res1 = 0 ;
3139     char temp2[STRMAX] ;
3140     int res2 ;
3141     int argvi = 0;
3142     dXSARGS;
3143
3144     if ((items < 2) || (items > 2)) {
3145       SWIG_croak("Usage: dumpfile_t_encrypt_cmd_set(self,encrypt_cmd);");
3146     }
3147     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3148     if (!SWIG_IsOK(res1)) {
3149       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_encrypt_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3150     }
3151     arg1 = (dumpfile_t *)(argp1);
3152     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3153     if (!SWIG_IsOK(res2)) {
3154       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_encrypt_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3155     }
3156     arg2 = (char *)(temp2);
3157     {
3158       strncpy(arg1->encrypt_cmd, arg2, STRMAX);
3159       if (arg1->encrypt_cmd[STRMAX-1] != '\0')
3160       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
3161     }
3162     ST(argvi) = sv_newmortal();
3163
3164
3165     XSRETURN(argvi);
3166   fail:
3167
3168
3169     SWIG_croak_null();
3170   }
3171 }
3172
3173
3174 XS(_wrap_dumpfile_t_encrypt_cmd_get) {
3175   {
3176     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3177     void *argp1 = 0 ;
3178     int res1 = 0 ;
3179     int argvi = 0;
3180     char *result = 0 ;
3181     dXSARGS;
3182
3183     if ((items < 1) || (items > 1)) {
3184       SWIG_croak("Usage: dumpfile_t_encrypt_cmd_get(self);");
3185     }
3186     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3187     if (!SWIG_IsOK(res1)) {
3188       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_encrypt_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3189     }
3190     arg1 = (dumpfile_t *)(argp1);
3191     result = (char *) ((arg1)->encrypt_cmd);
3192     {
3193       size_t size = STRMAX;
3194
3195       while (size && (result[size - 1] == '\0')) --size;
3196
3197       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3198     }
3199
3200     XSRETURN(argvi);
3201   fail:
3202
3203     SWIG_croak_null();
3204   }
3205 }
3206
3207
3208 XS(_wrap_dumpfile_t_decrypt_cmd_set) {
3209   {
3210     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3211     char *arg2 ;
3212     void *argp1 = 0 ;
3213     int res1 = 0 ;
3214     char temp2[STRMAX] ;
3215     int res2 ;
3216     int argvi = 0;
3217     dXSARGS;
3218
3219     if ((items < 2) || (items > 2)) {
3220       SWIG_croak("Usage: dumpfile_t_decrypt_cmd_set(self,decrypt_cmd);");
3221     }
3222     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3223     if (!SWIG_IsOK(res1)) {
3224       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_decrypt_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3225     }
3226     arg1 = (dumpfile_t *)(argp1);
3227     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3228     if (!SWIG_IsOK(res2)) {
3229       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_decrypt_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3230     }
3231     arg2 = (char *)(temp2);
3232     {
3233       strncpy(arg1->decrypt_cmd, arg2, STRMAX);
3234       if (arg1->decrypt_cmd[STRMAX-1] != '\0')
3235       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
3236     }
3237     ST(argvi) = sv_newmortal();
3238
3239
3240     XSRETURN(argvi);
3241   fail:
3242
3243
3244     SWIG_croak_null();
3245   }
3246 }
3247
3248
3249 XS(_wrap_dumpfile_t_decrypt_cmd_get) {
3250   {
3251     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3252     void *argp1 = 0 ;
3253     int res1 = 0 ;
3254     int argvi = 0;
3255     char *result = 0 ;
3256     dXSARGS;
3257
3258     if ((items < 1) || (items > 1)) {
3259       SWIG_croak("Usage: dumpfile_t_decrypt_cmd_get(self);");
3260     }
3261     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3262     if (!SWIG_IsOK(res1)) {
3263       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_decrypt_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3264     }
3265     arg1 = (dumpfile_t *)(argp1);
3266     result = (char *) ((arg1)->decrypt_cmd);
3267     {
3268       size_t size = STRMAX;
3269
3270       while (size && (result[size - 1] == '\0')) --size;
3271
3272       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3273     }
3274
3275     XSRETURN(argvi);
3276   fail:
3277
3278     SWIG_croak_null();
3279   }
3280 }
3281
3282
3283 XS(_wrap_dumpfile_t_srv_decrypt_opt_set) {
3284   {
3285     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3286     char *arg2 ;
3287     void *argp1 = 0 ;
3288     int res1 = 0 ;
3289     char temp2[STRMAX] ;
3290     int res2 ;
3291     int argvi = 0;
3292     dXSARGS;
3293
3294     if ((items < 2) || (items > 2)) {
3295       SWIG_croak("Usage: dumpfile_t_srv_decrypt_opt_set(self,srv_decrypt_opt);");
3296     }
3297     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3298     if (!SWIG_IsOK(res1)) {
3299       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_srv_decrypt_opt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3300     }
3301     arg1 = (dumpfile_t *)(argp1);
3302     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3303     if (!SWIG_IsOK(res2)) {
3304       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_srv_decrypt_opt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3305     }
3306     arg2 = (char *)(temp2);
3307     {
3308       strncpy(arg1->srv_decrypt_opt, arg2, STRMAX);
3309       if (arg1->srv_decrypt_opt[STRMAX-1] != '\0')
3310       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
3311     }
3312     ST(argvi) = sv_newmortal();
3313
3314
3315     XSRETURN(argvi);
3316   fail:
3317
3318
3319     SWIG_croak_null();
3320   }
3321 }
3322
3323
3324 XS(_wrap_dumpfile_t_srv_decrypt_opt_get) {
3325   {
3326     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3327     void *argp1 = 0 ;
3328     int res1 = 0 ;
3329     int argvi = 0;
3330     char *result = 0 ;
3331     dXSARGS;
3332
3333     if ((items < 1) || (items > 1)) {
3334       SWIG_croak("Usage: dumpfile_t_srv_decrypt_opt_get(self);");
3335     }
3336     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3337     if (!SWIG_IsOK(res1)) {
3338       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_srv_decrypt_opt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3339     }
3340     arg1 = (dumpfile_t *)(argp1);
3341     result = (char *) ((arg1)->srv_decrypt_opt);
3342     {
3343       size_t size = STRMAX;
3344
3345       while (size && (result[size - 1] == '\0')) --size;
3346
3347       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3348     }
3349
3350     XSRETURN(argvi);
3351   fail:
3352
3353     SWIG_croak_null();
3354   }
3355 }
3356
3357
3358 XS(_wrap_dumpfile_t_clnt_decrypt_opt_set) {
3359   {
3360     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3361     char *arg2 ;
3362     void *argp1 = 0 ;
3363     int res1 = 0 ;
3364     char temp2[STRMAX] ;
3365     int res2 ;
3366     int argvi = 0;
3367     dXSARGS;
3368
3369     if ((items < 2) || (items > 2)) {
3370       SWIG_croak("Usage: dumpfile_t_clnt_decrypt_opt_set(self,clnt_decrypt_opt);");
3371     }
3372     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3373     if (!SWIG_IsOK(res1)) {
3374       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_clnt_decrypt_opt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3375     }
3376     arg1 = (dumpfile_t *)(argp1);
3377     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3378     if (!SWIG_IsOK(res2)) {
3379       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_clnt_decrypt_opt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3380     }
3381     arg2 = (char *)(temp2);
3382     {
3383       strncpy(arg1->clnt_decrypt_opt, arg2, STRMAX);
3384       if (arg1->clnt_decrypt_opt[STRMAX-1] != '\0')
3385       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
3386     }
3387     ST(argvi) = sv_newmortal();
3388
3389
3390     XSRETURN(argvi);
3391   fail:
3392
3393
3394     SWIG_croak_null();
3395   }
3396 }
3397
3398
3399 XS(_wrap_dumpfile_t_clnt_decrypt_opt_get) {
3400   {
3401     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3402     void *argp1 = 0 ;
3403     int res1 = 0 ;
3404     int argvi = 0;
3405     char *result = 0 ;
3406     dXSARGS;
3407
3408     if ((items < 1) || (items > 1)) {
3409       SWIG_croak("Usage: dumpfile_t_clnt_decrypt_opt_get(self);");
3410     }
3411     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3412     if (!SWIG_IsOK(res1)) {
3413       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_clnt_decrypt_opt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3414     }
3415     arg1 = (dumpfile_t *)(argp1);
3416     result = (char *) ((arg1)->clnt_decrypt_opt);
3417     {
3418       size_t size = STRMAX;
3419
3420       while (size && (result[size - 1] == '\0')) --size;
3421
3422       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3423     }
3424
3425     XSRETURN(argvi);
3426   fail:
3427
3428     SWIG_croak_null();
3429   }
3430 }
3431
3432
3433 XS(_wrap_dumpfile_t_cont_filename_set) {
3434   {
3435     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3436     char *arg2 ;
3437     void *argp1 = 0 ;
3438     int res1 = 0 ;
3439     char temp2[STRMAX] ;
3440     int res2 ;
3441     int argvi = 0;
3442     dXSARGS;
3443
3444     if ((items < 2) || (items > 2)) {
3445       SWIG_croak("Usage: dumpfile_t_cont_filename_set(self,cont_filename);");
3446     }
3447     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3448     if (!SWIG_IsOK(res1)) {
3449       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_cont_filename_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3450     }
3451     arg1 = (dumpfile_t *)(argp1);
3452     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3453     if (!SWIG_IsOK(res2)) {
3454       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_cont_filename_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3455     }
3456     arg2 = (char *)(temp2);
3457     {
3458       strncpy(arg1->cont_filename, arg2, STRMAX);
3459       if (arg1->cont_filename[STRMAX-1] != '\0')
3460       SWIG_exception(SWIG_ValueError, "String too large for dumpfile_t");
3461     }
3462     ST(argvi) = sv_newmortal();
3463
3464
3465     XSRETURN(argvi);
3466   fail:
3467
3468
3469     SWIG_croak_null();
3470   }
3471 }
3472
3473
3474 XS(_wrap_dumpfile_t_cont_filename_get) {
3475   {
3476     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3477     void *argp1 = 0 ;
3478     int res1 = 0 ;
3479     int argvi = 0;
3480     char *result = 0 ;
3481     dXSARGS;
3482
3483     if ((items < 1) || (items > 1)) {
3484       SWIG_croak("Usage: dumpfile_t_cont_filename_get(self);");
3485     }
3486     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3487     if (!SWIG_IsOK(res1)) {
3488       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_cont_filename_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3489     }
3490     arg1 = (dumpfile_t *)(argp1);
3491     result = (char *) ((arg1)->cont_filename);
3492     {
3493       size_t size = STRMAX;
3494
3495       while (size && (result[size - 1] == '\0')) --size;
3496
3497       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3498     }
3499
3500     XSRETURN(argvi);
3501   fail:
3502
3503     SWIG_croak_null();
3504   }
3505 }
3506
3507
3508 XS(_wrap_dumpfile_t_dle_str_set) {
3509   {
3510     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3511     char *arg2 = (char *) 0 ;
3512     void *argp1 = 0 ;
3513     int res1 = 0 ;
3514     int res2 ;
3515     char *buf2 = 0 ;
3516     int alloc2 = 0 ;
3517     int argvi = 0;
3518     dXSARGS;
3519
3520     if ((items < 2) || (items > 2)) {
3521       SWIG_croak("Usage: dumpfile_t_dle_str_set(self,dle_str);");
3522     }
3523     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3524     if (!SWIG_IsOK(res1)) {
3525       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_dle_str_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3526     }
3527     arg1 = (dumpfile_t *)(argp1);
3528     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3529     if (!SWIG_IsOK(res2)) {
3530       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dumpfile_t_dle_str_set" "', argument " "2"" of type '" "char *""'");
3531     }
3532     arg2 = (char *)(buf2);
3533     if (arg1->dle_str) free((char*)arg1->dle_str);
3534     if (arg2) {
3535       size_t size = strlen((const char *)(arg2)) + 1;
3536       arg1->dle_str = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
3537     } else {
3538       arg1->dle_str = 0;
3539     }
3540     ST(argvi) = sv_newmortal();
3541
3542     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3543     XSRETURN(argvi);
3544   fail:
3545
3546     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3547     SWIG_croak_null();
3548   }
3549 }
3550
3551
3552 XS(_wrap_dumpfile_t_dle_str_get) {
3553   {
3554     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3555     void *argp1 = 0 ;
3556     int res1 = 0 ;
3557     int argvi = 0;
3558     char *result = 0 ;
3559     dXSARGS;
3560
3561     if ((items < 1) || (items > 1)) {
3562       SWIG_croak("Usage: dumpfile_t_dle_str_get(self);");
3563     }
3564     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3565     if (!SWIG_IsOK(res1)) {
3566       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_dle_str_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3567     }
3568     arg1 = (dumpfile_t *)(argp1);
3569     result = (char *) ((arg1)->dle_str);
3570     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3571
3572     XSRETURN(argvi);
3573   fail:
3574
3575     SWIG_croak_null();
3576   }
3577 }
3578
3579
3580 XS(_wrap_dumpfile_t_is_partial_set) {
3581   {
3582     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3583     int arg2 ;
3584     void *argp1 = 0 ;
3585     int res1 = 0 ;
3586     int argvi = 0;
3587     dXSARGS;
3588
3589     if ((items < 2) || (items > 2)) {
3590       SWIG_croak("Usage: dumpfile_t_is_partial_set(self,is_partial);");
3591     }
3592     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3593     if (!SWIG_IsOK(res1)) {
3594       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_is_partial_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3595     }
3596     arg1 = (dumpfile_t *)(argp1);
3597     {
3598       if (sizeof(signed int) == 1) {
3599         arg2 = amglue_SvI8(ST(1));
3600       } else if (sizeof(signed int) == 2) {
3601         arg2 = amglue_SvI16(ST(1));
3602       } else if (sizeof(signed int) == 4) {
3603         arg2 = amglue_SvI32(ST(1));
3604       } else if (sizeof(signed int) == 8) {
3605         arg2 = amglue_SvI64(ST(1));
3606       } else {
3607         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3608       }
3609     }
3610     if (arg1) (arg1)->is_partial = arg2;
3611     ST(argvi) = sv_newmortal();
3612
3613
3614     XSRETURN(argvi);
3615   fail:
3616
3617
3618     SWIG_croak_null();
3619   }
3620 }
3621
3622
3623 XS(_wrap_dumpfile_t_is_partial_get) {
3624   {
3625     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3626     void *argp1 = 0 ;
3627     int res1 = 0 ;
3628     int argvi = 0;
3629     int result;
3630     dXSARGS;
3631
3632     if ((items < 1) || (items > 1)) {
3633       SWIG_croak("Usage: dumpfile_t_is_partial_get(self);");
3634     }
3635     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3636     if (!SWIG_IsOK(res1)) {
3637       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_is_partial_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3638     }
3639     arg1 = (dumpfile_t *)(argp1);
3640     result = (int) ((arg1)->is_partial);
3641     {
3642       ST(argvi) = sv_2mortal(amglue_newSVi64(result));
3643       argvi++;
3644     }
3645
3646     XSRETURN(argvi);
3647   fail:
3648
3649     SWIG_croak_null();
3650   }
3651 }
3652
3653
3654 XS(_wrap_dumpfile_t_partnum_set) {
3655   {
3656     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3657     int arg2 ;
3658     void *argp1 = 0 ;
3659     int res1 = 0 ;
3660     int argvi = 0;
3661     dXSARGS;
3662
3663     if ((items < 2) || (items > 2)) {
3664       SWIG_croak("Usage: dumpfile_t_partnum_set(self,partnum);");
3665     }
3666     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3667     if (!SWIG_IsOK(res1)) {
3668       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_partnum_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3669     }
3670     arg1 = (dumpfile_t *)(argp1);
3671     {
3672       if (sizeof(signed int) == 1) {
3673         arg2 = amglue_SvI8(ST(1));
3674       } else if (sizeof(signed int) == 2) {
3675         arg2 = amglue_SvI16(ST(1));
3676       } else if (sizeof(signed int) == 4) {
3677         arg2 = amglue_SvI32(ST(1));
3678       } else if (sizeof(signed int) == 8) {
3679         arg2 = amglue_SvI64(ST(1));
3680       } else {
3681         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3682       }
3683     }
3684     if (arg1) (arg1)->partnum = arg2;
3685     ST(argvi) = sv_newmortal();
3686
3687
3688     XSRETURN(argvi);
3689   fail:
3690
3691
3692     SWIG_croak_null();
3693   }
3694 }
3695
3696
3697 XS(_wrap_dumpfile_t_partnum_get) {
3698   {
3699     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3700     void *argp1 = 0 ;
3701     int res1 = 0 ;
3702     int argvi = 0;
3703     int result;
3704     dXSARGS;
3705
3706     if ((items < 1) || (items > 1)) {
3707       SWIG_croak("Usage: dumpfile_t_partnum_get(self);");
3708     }
3709     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3710     if (!SWIG_IsOK(res1)) {
3711       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_partnum_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3712     }
3713     arg1 = (dumpfile_t *)(argp1);
3714     result = (int) ((arg1)->partnum);
3715     {
3716       ST(argvi) = sv_2mortal(amglue_newSVi64(result));
3717       argvi++;
3718     }
3719
3720     XSRETURN(argvi);
3721   fail:
3722
3723     SWIG_croak_null();
3724   }
3725 }
3726
3727
3728 XS(_wrap_dumpfile_t_totalparts_set) {
3729   {
3730     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3731     int arg2 ;
3732     void *argp1 = 0 ;
3733     int res1 = 0 ;
3734     int argvi = 0;
3735     dXSARGS;
3736
3737     if ((items < 2) || (items > 2)) {
3738       SWIG_croak("Usage: dumpfile_t_totalparts_set(self,totalparts);");
3739     }
3740     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3741     if (!SWIG_IsOK(res1)) {
3742       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_totalparts_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3743     }
3744     arg1 = (dumpfile_t *)(argp1);
3745     {
3746       if (sizeof(signed int) == 1) {
3747         arg2 = amglue_SvI8(ST(1));
3748       } else if (sizeof(signed int) == 2) {
3749         arg2 = amglue_SvI16(ST(1));
3750       } else if (sizeof(signed int) == 4) {
3751         arg2 = amglue_SvI32(ST(1));
3752       } else if (sizeof(signed int) == 8) {
3753         arg2 = amglue_SvI64(ST(1));
3754       } else {
3755         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3756       }
3757     }
3758     if (arg1) (arg1)->totalparts = arg2;
3759     ST(argvi) = sv_newmortal();
3760
3761
3762     XSRETURN(argvi);
3763   fail:
3764
3765
3766     SWIG_croak_null();
3767   }
3768 }
3769
3770
3771 XS(_wrap_dumpfile_t_totalparts_get) {
3772   {
3773     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3774     void *argp1 = 0 ;
3775     int res1 = 0 ;
3776     int argvi = 0;
3777     int result;
3778     dXSARGS;
3779
3780     if ((items < 1) || (items > 1)) {
3781       SWIG_croak("Usage: dumpfile_t_totalparts_get(self);");
3782     }
3783     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3784     if (!SWIG_IsOK(res1)) {
3785       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_totalparts_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3786     }
3787     arg1 = (dumpfile_t *)(argp1);
3788     result = (int) ((arg1)->totalparts);
3789     {
3790       ST(argvi) = sv_2mortal(amglue_newSVi64(result));
3791       argvi++;
3792     }
3793
3794     XSRETURN(argvi);
3795   fail:
3796
3797     SWIG_croak_null();
3798   }
3799 }
3800
3801
3802 XS(_wrap_dumpfile_t_blocksize_set) {
3803   {
3804     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3805     size_t arg2 ;
3806     void *argp1 = 0 ;
3807     int res1 = 0 ;
3808     int argvi = 0;
3809     dXSARGS;
3810
3811     if ((items < 2) || (items > 2)) {
3812       SWIG_croak("Usage: dumpfile_t_blocksize_set(self,blocksize);");
3813     }
3814     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3815     if (!SWIG_IsOK(res1)) {
3816       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_blocksize_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3817     }
3818     arg1 = (dumpfile_t *)(argp1);
3819     {
3820       if (sizeof(size_t) == 1) {
3821         arg2 = amglue_SvU8(ST(1));
3822       } else if (sizeof(size_t) == 2) {
3823         arg2 = amglue_SvU16(ST(1));
3824       } else if (sizeof(size_t) == 4) {
3825         arg2 = amglue_SvU32(ST(1));
3826       } else if (sizeof(size_t) == 8) {
3827         arg2 = amglue_SvU64(ST(1));
3828       } else {
3829         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
3830       }
3831     }
3832     if (arg1) (arg1)->blocksize = arg2;
3833     ST(argvi) = sv_newmortal();
3834
3835
3836     XSRETURN(argvi);
3837   fail:
3838
3839
3840     SWIG_croak_null();
3841   }
3842 }
3843
3844
3845 XS(_wrap_dumpfile_t_blocksize_get) {
3846   {
3847     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3848     void *argp1 = 0 ;
3849     int res1 = 0 ;
3850     int argvi = 0;
3851     size_t result;
3852     dXSARGS;
3853
3854     if ((items < 1) || (items > 1)) {
3855       SWIG_croak("Usage: dumpfile_t_blocksize_get(self);");
3856     }
3857     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3858     if (!SWIG_IsOK(res1)) {
3859       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumpfile_t_blocksize_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3860     }
3861     arg1 = (dumpfile_t *)(argp1);
3862     result =  ((arg1)->blocksize);
3863     {
3864       ST(argvi) = sv_2mortal(amglue_newSVu64(result));
3865       argvi++;
3866     }
3867
3868     XSRETURN(argvi);
3869   fail:
3870
3871     SWIG_croak_null();
3872   }
3873 }
3874
3875
3876 XS(_wrap_new_dumpfile_t) {
3877   {
3878     int argvi = 0;
3879     dumpfile_t *result = 0 ;
3880     dXSARGS;
3881
3882     if ((items < 0) || (items > 0)) {
3883       SWIG_croak("Usage: new_dumpfile_t();");
3884     }
3885     result = (dumpfile_t *)new_dumpfile_t();
3886     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3887     XSRETURN(argvi);
3888   fail:
3889     SWIG_croak_null();
3890   }
3891 }
3892
3893
3894 XS(_wrap_delete_dumpfile_t__SWIG_1) {
3895   {
3896     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3897     void *argp1 = 0 ;
3898     int res1 = 0 ;
3899     int argvi = 0;
3900     dXSARGS;
3901
3902     if ((items < 1) || (items > 1)) {
3903       SWIG_croak("Usage: delete_dumpfile_t(self);");
3904     }
3905     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, SWIG_POINTER_DISOWN |  0 );
3906     if (!SWIG_IsOK(res1)) {
3907       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_dumpfile_t" "', argument " "1"" of type '" "dumpfile_t *""'");
3908     }
3909     arg1 = (dumpfile_t *)(argp1);
3910     free((char *) arg1);
3911     ST(argvi) = sv_newmortal();
3912
3913     XSRETURN(argvi);
3914   fail:
3915
3916     SWIG_croak_null();
3917   }
3918 }
3919
3920
3921 XS(_wrap_delete_dumpfile_t) {
3922   dXSARGS;
3923
3924   {
3925     unsigned long _index = 0;
3926     SWIG_TypeRank _rank = 0;
3927     if (items == 1) {
3928       SWIG_TypeRank _ranki = 0;
3929       SWIG_TypeRank _rankm = 0;
3930       SWIG_TypeRank _pi = 1;
3931       int _v = 0;
3932       {
3933         void *vptr = 0;
3934         int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_dumpfile_t, 0);
3935         _v = SWIG_CheckState(res);
3936       }
3937       if (!_v) goto check_1;
3938       _ranki += _v*_pi;
3939       _rankm += _pi;
3940       _pi *= SWIG_MAXCASTRANK;
3941       if (!_index || (_ranki < _rank)) {
3942         _rank = _ranki; _index = 1;
3943         if (_rank == _rankm) goto dispatch;
3944       }
3945     }
3946   check_1:
3947
3948   dispatch:
3949     switch(_index) {
3950     case 1:
3951       ++PL_markstack_ptr; SWIG_CALLXS(_wrap_delete_dumpfile_t__SWIG_1); return;
3952     }
3953   }
3954
3955   croak("No matching function for overloaded 'delete_dumpfile_t'");
3956   XSRETURN(0);
3957 }
3958
3959
3960
3961 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3962
3963 static swig_type_info _swigt__p_a_STRMAX__char = {"_p_a_STRMAX__char", "char (*)[STRMAX]|string_t *", 0, 0, (void*)0, 0};
3964 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
3965 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
3966 static swig_type_info _swigt__p_dumpfile_t = {"_p_dumpfile_t", "dumpfile_t *", 0, 0, (void*)"Amanda::Types::dumpfile_t", 0};
3967 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
3968 static swig_type_info _swigt__p_int = {"_p_int", "int *|filetype_t *|gboolean *", 0, 0, (void*)0, 0};
3969 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
3970
3971 static swig_type_info *swig_type_initial[] = {
3972   &_swigt__p_a_STRMAX__char,
3973   &_swigt__p_char,
3974   &_swigt__p_double,
3975   &_swigt__p_dumpfile_t,
3976   &_swigt__p_float,
3977   &_swigt__p_int,
3978   &_swigt__p_unsigned_char,
3979 };
3980
3981 static swig_cast_info _swigc__p_a_STRMAX__char[] = {  {&_swigt__p_a_STRMAX__char, 0, 0, 0},{0, 0, 0, 0}};
3982 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3983 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
3984 static swig_cast_info _swigc__p_dumpfile_t[] = {  {&_swigt__p_dumpfile_t, 0, 0, 0},{0, 0, 0, 0}};
3985 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
3986 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
3987 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
3988
3989 static swig_cast_info *swig_cast_initial[] = {
3990   _swigc__p_a_STRMAX__char,
3991   _swigc__p_char,
3992   _swigc__p_double,
3993   _swigc__p_dumpfile_t,
3994   _swigc__p_float,
3995   _swigc__p_int,
3996   _swigc__p_unsigned_char,
3997 };
3998
3999
4000 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4001
4002 static swig_constant_info swig_constants[] = {
4003 {0,0,0,0,0,0}
4004 };
4005 #ifdef __cplusplus
4006 }
4007 #endif
4008 static swig_variable_info swig_variables[] = {
4009 {0,0,0,0}
4010 };
4011 static swig_command_info swig_commands[] = {
4012 {"Amanda::Typesc::dumpfile_t_type_set", _wrap_dumpfile_t_type_set},
4013 {"Amanda::Typesc::dumpfile_t_type_get", _wrap_dumpfile_t_type_get},
4014 {"Amanda::Typesc::dumpfile_t_datestamp_set", _wrap_dumpfile_t_datestamp_set},
4015 {"Amanda::Typesc::dumpfile_t_datestamp_get", _wrap_dumpfile_t_datestamp_get},
4016 {"Amanda::Typesc::dumpfile_t_dumplevel_set", _wrap_dumpfile_t_dumplevel_set},
4017 {"Amanda::Typesc::dumpfile_t_dumplevel_get", _wrap_dumpfile_t_dumplevel_get},
4018 {"Amanda::Typesc::dumpfile_t_compressed_set", _wrap_dumpfile_t_compressed_set},
4019 {"Amanda::Typesc::dumpfile_t_compressed_get", _wrap_dumpfile_t_compressed_get},
4020 {"Amanda::Typesc::dumpfile_t_encrypted_set", _wrap_dumpfile_t_encrypted_set},
4021 {"Amanda::Typesc::dumpfile_t_encrypted_get", _wrap_dumpfile_t_encrypted_get},
4022 {"Amanda::Typesc::dumpfile_t_comp_suffix_set", _wrap_dumpfile_t_comp_suffix_set},
4023 {"Amanda::Typesc::dumpfile_t_comp_suffix_get", _wrap_dumpfile_t_comp_suffix_get},
4024 {"Amanda::Typesc::dumpfile_t_encrypt_suffix_set", _wrap_dumpfile_t_encrypt_suffix_set},
4025 {"Amanda::Typesc::dumpfile_t_encrypt_suffix_get", _wrap_dumpfile_t_encrypt_suffix_get},
4026 {"Amanda::Typesc::dumpfile_t_name_set", _wrap_dumpfile_t_name_set},
4027 {"Amanda::Typesc::dumpfile_t_name_get", _wrap_dumpfile_t_name_get},
4028 {"Amanda::Typesc::dumpfile_t_disk_set", _wrap_dumpfile_t_disk_set},
4029 {"Amanda::Typesc::dumpfile_t_disk_get", _wrap_dumpfile_t_disk_get},
4030 {"Amanda::Typesc::dumpfile_t_program_set", _wrap_dumpfile_t_program_set},
4031 {"Amanda::Typesc::dumpfile_t_program_get", _wrap_dumpfile_t_program_get},
4032 {"Amanda::Typesc::dumpfile_t_application_set", _wrap_dumpfile_t_application_set},
4033 {"Amanda::Typesc::dumpfile_t_application_get", _wrap_dumpfile_t_application_get},
4034 {"Amanda::Typesc::dumpfile_t_srvcompprog_set", _wrap_dumpfile_t_srvcompprog_set},
4035 {"Amanda::Typesc::dumpfile_t_srvcompprog_get", _wrap_dumpfile_t_srvcompprog_get},
4036 {"Amanda::Typesc::dumpfile_t_clntcompprog_set", _wrap_dumpfile_t_clntcompprog_set},
4037 {"Amanda::Typesc::dumpfile_t_clntcompprog_get", _wrap_dumpfile_t_clntcompprog_get},
4038 {"Amanda::Typesc::dumpfile_t_srv_encrypt_set", _wrap_dumpfile_t_srv_encrypt_set},
4039 {"Amanda::Typesc::dumpfile_t_srv_encrypt_get", _wrap_dumpfile_t_srv_encrypt_get},
4040 {"Amanda::Typesc::dumpfile_t_clnt_encrypt_set", _wrap_dumpfile_t_clnt_encrypt_set},
4041 {"Amanda::Typesc::dumpfile_t_clnt_encrypt_get", _wrap_dumpfile_t_clnt_encrypt_get},
4042 {"Amanda::Typesc::dumpfile_t_recover_cmd_set", _wrap_dumpfile_t_recover_cmd_set},
4043 {"Amanda::Typesc::dumpfile_t_recover_cmd_get", _wrap_dumpfile_t_recover_cmd_get},
4044 {"Amanda::Typesc::dumpfile_t_uncompress_cmd_set", _wrap_dumpfile_t_uncompress_cmd_set},
4045 {"Amanda::Typesc::dumpfile_t_uncompress_cmd_get", _wrap_dumpfile_t_uncompress_cmd_get},
4046 {"Amanda::Typesc::dumpfile_t_encrypt_cmd_set", _wrap_dumpfile_t_encrypt_cmd_set},
4047 {"Amanda::Typesc::dumpfile_t_encrypt_cmd_get", _wrap_dumpfile_t_encrypt_cmd_get},
4048 {"Amanda::Typesc::dumpfile_t_decrypt_cmd_set", _wrap_dumpfile_t_decrypt_cmd_set},
4049 {"Amanda::Typesc::dumpfile_t_decrypt_cmd_get", _wrap_dumpfile_t_decrypt_cmd_get},
4050 {"Amanda::Typesc::dumpfile_t_srv_decrypt_opt_set", _wrap_dumpfile_t_srv_decrypt_opt_set},
4051 {"Amanda::Typesc::dumpfile_t_srv_decrypt_opt_get", _wrap_dumpfile_t_srv_decrypt_opt_get},
4052 {"Amanda::Typesc::dumpfile_t_clnt_decrypt_opt_set", _wrap_dumpfile_t_clnt_decrypt_opt_set},
4053 {"Amanda::Typesc::dumpfile_t_clnt_decrypt_opt_get", _wrap_dumpfile_t_clnt_decrypt_opt_get},
4054 {"Amanda::Typesc::dumpfile_t_cont_filename_set", _wrap_dumpfile_t_cont_filename_set},
4055 {"Amanda::Typesc::dumpfile_t_cont_filename_get", _wrap_dumpfile_t_cont_filename_get},
4056 {"Amanda::Typesc::dumpfile_t_dle_str_set", _wrap_dumpfile_t_dle_str_set},
4057 {"Amanda::Typesc::dumpfile_t_dle_str_get", _wrap_dumpfile_t_dle_str_get},
4058 {"Amanda::Typesc::dumpfile_t_is_partial_set", _wrap_dumpfile_t_is_partial_set},
4059 {"Amanda::Typesc::dumpfile_t_is_partial_get", _wrap_dumpfile_t_is_partial_get},
4060 {"Amanda::Typesc::dumpfile_t_partnum_set", _wrap_dumpfile_t_partnum_set},
4061 {"Amanda::Typesc::dumpfile_t_partnum_get", _wrap_dumpfile_t_partnum_get},
4062 {"Amanda::Typesc::dumpfile_t_totalparts_set", _wrap_dumpfile_t_totalparts_set},
4063 {"Amanda::Typesc::dumpfile_t_totalparts_get", _wrap_dumpfile_t_totalparts_get},
4064 {"Amanda::Typesc::dumpfile_t_blocksize_set", _wrap_dumpfile_t_blocksize_set},
4065 {"Amanda::Typesc::dumpfile_t_blocksize_get", _wrap_dumpfile_t_blocksize_get},
4066 {"Amanda::Typesc::new_dumpfile_t", _wrap_new_dumpfile_t},
4067 {"Amanda::Typesc::delete_dumpfile_t", _wrap_delete_dumpfile_t},
4068 {0,0}
4069 };
4070 /* -----------------------------------------------------------------------------
4071  * Type initialization:
4072  * This problem is tough by the requirement that no dynamic
4073  * memory is used. Also, since swig_type_info structures store pointers to
4074  * swig_cast_info structures and swig_cast_info structures store pointers back
4075  * to swig_type_info structures, we need some lookup code at initialization.
4076  * The idea is that swig generates all the structures that are needed.
4077  * The runtime then collects these partially filled structures.
4078  * The SWIG_InitializeModule function takes these initial arrays out of
4079  * swig_module, and does all the lookup, filling in the swig_module.types
4080  * array with the correct data and linking the correct swig_cast_info
4081  * structures together.
4082  *
4083  * The generated swig_type_info structures are assigned staticly to an initial
4084  * array. We just loop through that array, and handle each type individually.
4085  * First we lookup if this type has been already loaded, and if so, use the
4086  * loaded structure instead of the generated one. Then we have to fill in the
4087  * cast linked list. The cast data is initially stored in something like a
4088  * two-dimensional array. Each row corresponds to a type (there are the same
4089  * number of rows as there are in the swig_type_initial array). Each entry in
4090  * a column is one of the swig_cast_info structures for that type.
4091  * The cast_initial array is actually an array of arrays, because each row has
4092  * a variable number of columns. So to actually build the cast linked list,
4093  * we find the array of casts associated with the type, and loop through it
4094  * adding the casts to the list. The one last trick we need to do is making
4095  * sure the type pointer in the swig_cast_info struct is correct.
4096  *
4097  * First off, we lookup the cast->type name to see if it is already loaded.
4098  * There are three cases to handle:
4099  *  1) If the cast->type has already been loaded AND the type we are adding
4100  *     casting info to has not been loaded (it is in this module), THEN we
4101  *     replace the cast->type pointer with the type pointer that has already
4102  *     been loaded.
4103  *  2) If BOTH types (the one we are adding casting info to, and the
4104  *     cast->type) are loaded, THEN the cast info has already been loaded by
4105  *     the previous module so we just ignore it.
4106  *  3) Finally, if cast->type has not already been loaded, then we add that
4107  *     swig_cast_info to the linked list (because the cast->type) pointer will
4108  *     be correct.
4109  * ----------------------------------------------------------------------------- */
4110
4111 #ifdef __cplusplus
4112 extern "C" {
4113 #if 0
4114 } /* c-mode */
4115 #endif
4116 #endif
4117
4118 #if 0
4119 #define SWIGRUNTIME_DEBUG
4120 #endif
4121
4122
4123 SWIGRUNTIME void
4124 SWIG_InitializeModule(void *clientdata) {
4125   size_t i;
4126   swig_module_info *module_head, *iter;
4127   int found, init;
4128
4129   clientdata = clientdata;
4130
4131   /* check to see if the circular list has been setup, if not, set it up */
4132   if (swig_module.next==0) {
4133     /* Initialize the swig_module */
4134     swig_module.type_initial = swig_type_initial;
4135     swig_module.cast_initial = swig_cast_initial;
4136     swig_module.next = &swig_module;
4137     init = 1;
4138   } else {
4139     init = 0;
4140   }
4141
4142   /* Try and load any already created modules */
4143   module_head = SWIG_GetModule(clientdata);
4144   if (!module_head) {
4145     /* This is the first module loaded for this interpreter */
4146     /* so set the swig module into the interpreter */
4147     SWIG_SetModule(clientdata, &swig_module);
4148     module_head = &swig_module;
4149   } else {
4150     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4151     found=0;
4152     iter=module_head;
4153     do {
4154       if (iter==&swig_module) {
4155         found=1;
4156         break;
4157       }
4158       iter=iter->next;
4159     } while (iter!= module_head);
4160
4161     /* if the is found in the list, then all is done and we may leave */
4162     if (found) return;
4163     /* otherwise we must add out module into the list */
4164     swig_module.next = module_head->next;
4165     module_head->next = &swig_module;
4166   }
4167
4168   /* When multiple interpeters are used, a module could have already been initialized in
4169        a different interpreter, but not yet have a pointer in this interpreter.
4170        In this case, we do not want to continue adding types... everything should be
4171        set up already */
4172   if (init == 0) return;
4173
4174   /* Now work on filling in swig_module.types */
4175 #ifdef SWIGRUNTIME_DEBUG
4176   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
4177 #endif
4178   for (i = 0; i < swig_module.size; ++i) {
4179     swig_type_info *type = 0;
4180     swig_type_info *ret;
4181     swig_cast_info *cast;
4182
4183 #ifdef SWIGRUNTIME_DEBUG
4184     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4185 #endif
4186
4187     /* if there is another module already loaded */
4188     if (swig_module.next != &swig_module) {
4189       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4190     }
4191     if (type) {
4192       /* Overwrite clientdata field */
4193 #ifdef SWIGRUNTIME_DEBUG
4194       printf("SWIG_InitializeModule: found type %s\n", type->name);
4195 #endif
4196       if (swig_module.type_initial[i]->clientdata) {
4197         type->clientdata = swig_module.type_initial[i]->clientdata;
4198 #ifdef SWIGRUNTIME_DEBUG
4199         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
4200 #endif
4201       }
4202     } else {
4203       type = swig_module.type_initial[i];
4204     }
4205
4206     /* Insert casting types */
4207     cast = swig_module.cast_initial[i];
4208     while (cast->type) {
4209       /* Don't need to add information already in the list */
4210       ret = 0;
4211 #ifdef SWIGRUNTIME_DEBUG
4212       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4213 #endif
4214       if (swig_module.next != &swig_module) {
4215         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4216 #ifdef SWIGRUNTIME_DEBUG
4217         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4218 #endif
4219       }
4220       if (ret) {
4221         if (type == swig_module.type_initial[i]) {
4222 #ifdef SWIGRUNTIME_DEBUG
4223           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4224 #endif
4225           cast->type = ret;
4226           ret = 0;
4227         } else {
4228           /* Check for casting already in the list */
4229           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4230 #ifdef SWIGRUNTIME_DEBUG
4231           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4232 #endif
4233           if (!ocast) ret = 0;
4234         }
4235       }
4236
4237       if (!ret) {
4238 #ifdef SWIGRUNTIME_DEBUG
4239         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4240 #endif
4241         if (type->cast) {
4242           type->cast->prev = cast;
4243           cast->next = type->cast;
4244         }
4245         type->cast = cast;
4246       }
4247       cast++;
4248     }
4249     /* Set entry in modules->types array equal to the type */
4250     swig_module.types[i] = type;
4251   }
4252   swig_module.types[i] = 0;
4253
4254 #ifdef SWIGRUNTIME_DEBUG
4255   printf("**** SWIG_InitializeModule: Cast List ******\n");
4256   for (i = 0; i < swig_module.size; ++i) {
4257     int j = 0;
4258     swig_cast_info *cast = swig_module.cast_initial[i];
4259     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4260     while (cast->type) {
4261       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4262       cast++;
4263       ++j;
4264     }
4265     printf("---- Total casts: %d\n",j);
4266   }
4267   printf("**** SWIG_InitializeModule: Cast List ******\n");
4268 #endif
4269 }
4270
4271 /* This function will propagate the clientdata field of type to
4272 * any new swig_type_info structures that have been added into the list
4273 * of equivalent types.  It is like calling
4274 * SWIG_TypeClientData(type, clientdata) a second time.
4275 */
4276 SWIGRUNTIME void
4277 SWIG_PropagateClientData(void) {
4278   size_t i;
4279   swig_cast_info *equiv;
4280   static int init_run = 0;
4281
4282   if (init_run) return;
4283   init_run = 1;
4284
4285   for (i = 0; i < swig_module.size; i++) {
4286     if (swig_module.types[i]->clientdata) {
4287       equiv = swig_module.types[i]->cast;
4288       while (equiv) {
4289         if (!equiv->converter) {
4290           if (equiv->type && !equiv->type->clientdata)
4291           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4292         }
4293         equiv = equiv->next;
4294       }
4295     }
4296   }
4297 }
4298
4299 #ifdef __cplusplus
4300 #if 0
4301 {
4302   /* c-mode */
4303 #endif
4304 }
4305 #endif
4306
4307
4308
4309 #ifdef __cplusplus
4310 extern "C"
4311 #endif
4312
4313 XS(SWIG_init) {
4314   dXSARGS;
4315   int i;
4316
4317   SWIG_InitializeModule(0);
4318
4319   /* Install commands */
4320   for (i = 0; swig_commands[i].name; i++) {
4321     newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
4322   }
4323
4324   /* Install variables */
4325   for (i = 0; swig_variables[i].name; i++) {
4326     SV *sv;
4327     sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
4328     if (swig_variables[i].type) {
4329       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
4330     } else {
4331       sv_setiv(sv,(IV) 0);
4332     }
4333     swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
4334   }
4335
4336   /* Install constant */
4337   for (i = 0; swig_constants[i].type; i++) {
4338     SV *sv;
4339     sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
4340     switch(swig_constants[i].type) {
4341     case SWIG_INT:
4342       sv_setiv(sv, (IV) swig_constants[i].lvalue);
4343       break;
4344     case SWIG_FLOAT:
4345       sv_setnv(sv, (double) swig_constants[i].dvalue);
4346       break;
4347     case SWIG_STRING:
4348       sv_setpv(sv, (char *) swig_constants[i].pvalue);
4349       break;
4350     case SWIG_POINTER:
4351       SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
4352       break;
4353     case SWIG_BINARY:
4354       SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
4355       break;
4356     default:
4357       break;
4358     }
4359     SvREADONLY_on(sv);
4360   }
4361
4362   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4363     SV *sv = get_sv((char*) SWIG_prefix "F_UNKNOWN", TRUE | 0x2 | GV_ADDMULTI);
4364     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_UNKNOWN)));
4365     SvREADONLY_on(sv);
4366   } while(0) /*@SWIG@*/;
4367   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4368     SV *sv = get_sv((char*) SWIG_prefix "F_WEIRD", TRUE | 0x2 | GV_ADDMULTI);
4369     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_WEIRD)));
4370     SvREADONLY_on(sv);
4371   } while(0) /*@SWIG@*/;
4372   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4373     SV *sv = get_sv((char*) SWIG_prefix "F_TAPESTART", TRUE | 0x2 | GV_ADDMULTI);
4374     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_TAPESTART)));
4375     SvREADONLY_on(sv);
4376   } while(0) /*@SWIG@*/;
4377   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4378     SV *sv = get_sv((char*) SWIG_prefix "F_TAPEEND", TRUE | 0x2 | GV_ADDMULTI);
4379     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_TAPEEND)));
4380     SvREADONLY_on(sv);
4381   } while(0) /*@SWIG@*/;
4382   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4383     SV *sv = get_sv((char*) SWIG_prefix "F_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
4384     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_DUMPFILE)));
4385     SvREADONLY_on(sv);
4386   } while(0) /*@SWIG@*/;
4387   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4388     SV *sv = get_sv((char*) SWIG_prefix "F_CONT_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
4389     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_CONT_DUMPFILE)));
4390     SvREADONLY_on(sv);
4391   } while(0) /*@SWIG@*/;
4392   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4393     SV *sv = get_sv((char*) SWIG_prefix "F_SPLIT_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
4394     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_SPLIT_DUMPFILE)));
4395     SvREADONLY_on(sv);
4396   } while(0) /*@SWIG@*/;
4397   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4398     SV *sv = get_sv((char*) SWIG_prefix "F_EMPTY", TRUE | 0x2 | GV_ADDMULTI);
4399     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_EMPTY)));
4400     SvREADONLY_on(sv);
4401   } while(0) /*@SWIG@*/;
4402   SWIG_TypeClientData(SWIGTYPE_p_dumpfile_t, (void*) "Amanda::Types::dumpfile_t");
4403   ST(0) = &PL_sv_yes;
4404   XSRETURN(1);
4405 }
4406