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