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 #include "../config/config.h"
  12
  13
  14 #define SWIGPERL
  15 #define SWIG_CASTRANK_MODE
  16
  17 /* -----------------------------------------------------------------------------
  18  *  This section contains generic SWIG labels for method/variable
  19  *  declarations/attributes, and other compiler dependent labels.
  20  * ----------------------------------------------------------------------------- */
  21
  22 /* template workaround for compilers that cannot correctly implement the C++ standard */
  23 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  24 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  25 #  define SWIGTEMPLATEDISAMBIGUATOR template
  26 # elif defined(__HP_aCC)
  27 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  28 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  29 #  define SWIGTEMPLATEDISAMBIGUATOR template
  30 # else
  31 #  define SWIGTEMPLATEDISAMBIGUATOR
  32 # endif
  33 #endif
  34
  35 /* inline attribute */
  36 #ifndef SWIGINLINE
  37 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  38 #   define SWIGINLINE inline
  39 # else
  40 #   define SWIGINLINE
  41 # endif
  42 #endif
  43
  44 /* attribute recognised by some compilers to avoid 'unused' warnings */
  45 #ifndef SWIGUNUSED
  46 # if defined(__GNUC__)
  47 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  48 #     define SWIGUNUSED __attribute__ ((__unused__))
  49 #   else
  50 #     define SWIGUNUSED
  51 #   endif
  52 # elif defined(__ICC)
  53 #   define SWIGUNUSED __attribute__ ((__unused__))
  54 # else
  55 #   define SWIGUNUSED
  56 # endif
  57 #endif
  58
  59 #ifndef SWIG_MSC_UNSUPPRESS_4505
  60 # if defined(_MSC_VER)
  61 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  62 # endif
  63 #endif
  64
  65 #ifndef SWIGUNUSEDPARM
  66 # ifdef __cplusplus
  67 #   define SWIGUNUSEDPARM(p)
  68 # else
  69 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  70 # endif
  71 #endif
  72
  73 /* internal SWIG method */
  74 #ifndef SWIGINTERN
  75 # define SWIGINTERN static SWIGUNUSED
  76 #endif
  77
  78 /* internal inline SWIG method */
  79 #ifndef SWIGINTERNINLINE
  80 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  81 #endif
  82
  83 /* exporting methods */
  84 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  85 #  ifndef GCC_HASCLASSVISIBILITY
  86 #    define GCC_HASCLASSVISIBILITY
  87 #  endif
  88 #endif
  89
  90 #ifndef SWIGEXPORT
  91 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  92 #   if defined(STATIC_LINKED)
  93 #     define SWIGEXPORT
  94 #   else
  95 #     define SWIGEXPORT __declspec(dllexport)
  96 #   endif
  97 # else
  98 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
  99 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 100 #   else
 101 #     define SWIGEXPORT
 102 #   endif
 103 # endif
 104 #endif
 105
 106 /* calling conventions for Windows */
 107 #ifndef SWIGSTDCALL
 108 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 109 #   define SWIGSTDCALL __stdcall
 110 # else
 111 #   define SWIGSTDCALL
 112 # endif
 113 #endif
 114
 115 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 116 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 117 # define _CRT_SECURE_NO_DEPRECATE
 118 #endif
 119
 120 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 121 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 122 # define _SCL_SECURE_NO_DEPRECATE
 123 #endif
 124
 125
 126 /* -----------------------------------------------------------------------------
 127  * swigrun.swg
 128  *
 129  * This file contains generic C API SWIG runtime support for pointer
 130  * type checking.
 131  * ----------------------------------------------------------------------------- */
 132
 133 /* This should only be incremented when either the layout of swig_type_info changes,
 134    or for whatever reason, the runtime changes incompatibly */
 135 #define SWIG_RUNTIME_VERSION "4"
 136
 137 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 138 #ifdef SWIG_TYPE_TABLE
 139 # define SWIG_QUOTE_STRING(x) #x
 140 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 141 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 142 #else
 143 # define SWIG_TYPE_TABLE_NAME
 144 #endif
 145
 146 /*
 147   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 148   creating a static or dynamic library from the SWIG runtime code.
 149   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
 150
 151   But only do this if strictly necessary, ie, if you have problems
 152   with your compiler or suchlike.
 153 */
 154
 155 #ifndef SWIGRUNTIME
 156 # define SWIGRUNTIME SWIGINTERN
 157 #endif
 158
 159 #ifndef SWIGRUNTIMEINLINE
 160 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 161 #endif
 162
 163 /*  Generic buffer size */
 164 #ifndef SWIG_BUFFER_SIZE
 165 # define SWIG_BUFFER_SIZE 1024
 166 #endif
 167
 168 /* Flags for pointer conversions */
 169 #define SWIG_POINTER_DISOWN        0x1
 170 #define SWIG_CAST_NEW_MEMORY       0x2
 171
 172 /* Flags for new pointer objects */
 173 #define SWIG_POINTER_OWN           0x1
 174
 175
 176 /*
 177    Flags/methods for returning states.
 178
 179    The SWIG conversion methods, as ConvertPtr, return and integer
 180    that tells if the conversion was successful or not. And if not,
 181    an error code can be returned (see swigerrors.swg for the codes).
 182
 183    Use the following macros/flags to set or process the returning
 184    states.
 185
 186    In old versions of SWIG, code such as the following was usually written:
 187
 188      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 189        // success code
 190      } else {
 191        //fail code
 192      }
 193
 194    Now you can be more explicit:
 195
 196     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 197     if (SWIG_IsOK(res)) {
 198       // success code
 199     } else {
 200       // fail code
 201     }
 202
 203    which is the same really, but now you can also do
 204
 205     Type *ptr;
 206     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 207     if (SWIG_IsOK(res)) {
 208       // success code
 209       if (SWIG_IsNewObj(res) {
 210         ...
 211         delete *ptr;
 212       } else {
 213         ...
 214       }
 215     } else {
 216       // fail code
 217     }
 218
 219    I.e., now SWIG_ConvertPtr can return new objects and you can
 220    identify the case and take care of the deallocation. Of course that
 221    also requires SWIG_ConvertPtr to return new result values, such as
 222
 223       int SWIG_ConvertPtr(obj, ptr,...) {
 224         if (<obj is ok>) {
 225           if (<need new object>) {
 226             *ptr = <ptr to new allocated object>;
 227             return SWIG_NEWOBJ;
 228           } else {
 229             *ptr = <ptr to old object>;
 230             return SWIG_OLDOBJ;
 231           }
 232         } else {
 233           return SWIG_BADOBJ;
 234         }
 235       }
 236
 237    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 238    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 239    SWIG errors code.
 240
 241    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 242    allows to return the 'cast rank', for example, if you have this
 243
 244        int food(double)
 245        int fooi(int);
 246
 247    and you call
 248
 249       food(1)   // cast rank '1'  (1 -> 1.0)
 250       fooi(1)   // cast rank '0'
 251
 252    just use the SWIG_AddCast()/SWIG_CheckState()
 253 */
 254
 255 #define SWIG_OK                    (0)
 256 #define SWIG_ERROR                 (-1)
 257 #define SWIG_IsOK(r)               (r >= 0)
 258 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 259
 260 /* The CastRankLimit says how many bits are used for the cast rank */
 261 #define SWIG_CASTRANKLIMIT         (1 << 8)
 262 /* The NewMask denotes the object was created (using new/malloc) */
 263 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 264 /* The TmpMask is for in/out typemaps that use temporal objects */
 265 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 266 /* Simple returning values */
 267 #define SWIG_BADOBJ                (SWIG_ERROR)
 268 #define SWIG_OLDOBJ                (SWIG_OK)
 269 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 270 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 271 /* Check, add and del mask methods */
 272 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 273 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 274 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 275 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 276 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 277 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 278
 279 /* Cast-Rank Mode */
 280 #if defined(SWIG_CASTRANK_MODE)
 281 #  ifndef SWIG_TypeRank
 282 #    define SWIG_TypeRank             unsigned long
 283 #  endif
 284 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 285 #    define SWIG_MAXCASTRANK          (2)
 286 #  endif
 287 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 288 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 289 SWIGINTERNINLINE int SWIG_AddCast(int r) {
 290   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 291 }
 292 SWIGINTERNINLINE int SWIG_CheckState(int r) {
 293   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
 294 }
 295 #else /* no cast-rank mode */
 296 #  define SWIG_AddCast
 297 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 298 #endif
 299
 300
 301 #include <string.h>
 302
 303 #ifdef __cplusplus
 304 extern "C" {
 305 #endif
 306
 307 typedef void *(*swig_converter_func)(void *, int *);
 308 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 309
 310 /* Structure to store information on one type */
 311 typedef struct swig_type_info {
 312   const char             *name;                 /* mangled name of this type */
 313   const char             *str;                  /* human readable name of this type */
 314   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 315   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 316   void                   *clientdata;           /* language specific type data */
 317   int                    owndata;               /* flag if the structure owns the clientdata */
 318 } swig_type_info;
 319
 320 /* Structure to store a type and conversion function used for casting */
 321 typedef struct swig_cast_info {
 322   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 323   swig_converter_func     converter;            /* function to cast the void pointers */
 324   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 325   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 326 } swig_cast_info;
 327
 328 /* Structure used to store module information
 329  * Each module generates one structure like this, and the runtime collects
 330  * all of these structures and stores them in a circularly linked list.*/
 331 typedef struct swig_module_info {
 332   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 333   size_t                 size;                  /* Number of types in this module */
 334   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 335   swig_type_info         **type_initial;        /* Array of initially generated type structures */
 336   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 337   void                    *clientdata;          /* Language specific module data */
 338 } swig_module_info;
 339
 340 /*
 341   Compare two type names skipping the space characters, therefore
 342   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 343
 344   Return 0 when the two name types are equivalent, as in
 345   strncmp, but skipping ' '.
 346 */
 347 SWIGRUNTIME int
 348 SWIG_TypeNameComp(const char *f1, const char *l1,
 349                   const char *f2, const char *l2) {
 350   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 351     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 352     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 353     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 354   }
 355   return (int)((l1 - f1) - (l2 - f2));
 356 }
 357
 358 /*
 359   Check type equivalence in a name list like <name1>|<name2>|...
 360   Return 0 if not equal, 1 if equal
 361 */
 362 SWIGRUNTIME int
 363 SWIG_TypeEquiv(const char *nb, const char *tb) {
 364   int equiv = 0;
 365   const char* te = tb + strlen(tb);
 366   const char* ne = nb;
 367   while (!equiv && *ne) {
 368     for (nb = ne; *ne; ++ne) {
 369       if (*ne == '|') break;
 370     }
 371     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 372     if (*ne) ++ne;
 373   }
 374   return equiv;
 375 }
 376
 377 /*
 378   Check type equivalence in a name list like <name1>|<name2>|...
 379   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 380 */
 381 SWIGRUNTIME int
 382 SWIG_TypeCompare(const char *nb, const char *tb) {
 383   int equiv = 0;
 384   const char* te = tb + strlen(tb);
 385   const char* ne = nb;
 386   while (!equiv && *ne) {
 387     for (nb = ne; *ne; ++ne) {
 388       if (*ne == '|') break;
 389     }
 390     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 391     if (*ne) ++ne;
 392   }
 393   return equiv;
 394 }
 395
 396
 397 /*
 398   Check the typename
 399 */
 400 SWIGRUNTIME swig_cast_info *
 401 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 402   if (ty) {
 403     swig_cast_info *iter = ty->cast;
 404     while (iter) {
 405       if (strcmp(iter->type->name, c) == 0) {
 406         if (iter == ty->cast)
 407           return iter;
 408         /* Move iter to the top of the linked list */
 409         iter->prev->next = iter->next;
 410         if (iter->next)
 411           iter->next->prev = iter->prev;
 412         iter->next = ty->cast;
 413         iter->prev = 0;
 414         if (ty->cast) ty->cast->prev = iter;
 415         ty->cast = iter;
 416         return iter;
 417       }
 418       iter = iter->next;
 419     }
 420   }
 421   return 0;
 422 }
 423
 424 /*
 425   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
 426 */
 427 SWIGRUNTIME swig_cast_info *
 428 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
 429   if (ty) {
 430     swig_cast_info *iter = ty->cast;
 431     while (iter) {
 432       if (iter->type == from) {
 433         if (iter == ty->cast)
 434           return iter;
 435         /* Move iter to the top of the linked list */
 436         iter->prev->next = iter->next;
 437         if (iter->next)
 438           iter->next->prev = iter->prev;
 439         iter->next = ty->cast;
 440         iter->prev = 0;
 441         if (ty->cast) ty->cast->prev = iter;
 442         ty->cast = iter;
 443         return iter;
 444       }
 445       iter = iter->next;
 446     }
 447   }
 448   return 0;
 449 }
 450
 451 /*
 452   Cast a pointer up an inheritance hierarchy
 453 */
 454 SWIGRUNTIMEINLINE void *
 455 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
 456   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 457 }
 458
 459 /*
 460    Dynamic pointer casting. Down an inheritance hierarchy
 461 */
 462 SWIGRUNTIME swig_type_info *
 463 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 464   swig_type_info *lastty = ty;
 465   if (!ty || !ty->dcast) return ty;
 466   while (ty && (ty->dcast)) {
 467     ty = (*ty->dcast)(ptr);
 468     if (ty) lastty = ty;
 469   }
 470   return lastty;
 471 }
 472
 473 /*
 474   Return the name associated with this type
 475 */
 476 SWIGRUNTIMEINLINE const char *
 477 SWIG_TypeName(const swig_type_info *ty) {
 478   return ty->name;
 479 }
 480
 481 /*
 482   Return the pretty name associated with this type,
 483   that is an unmangled type name in a form presentable to the user.
 484 */
 485 SWIGRUNTIME const char *
 486 SWIG_TypePrettyName(const swig_type_info *type) {
 487   /* The "str" field contains the equivalent pretty names of the
 488      type, separated by vertical-bar characters.  We choose
 489      to print the last name, as it is often (?) the most
 490      specific. */
 491   if (!type) return NULL;
 492   if (type->str != NULL) {
 493     const char *last_name = type->str;
 494     const char *s;
 495     for (s = type->str; *s; s++)
 496       if (*s == '|') last_name = s+1;
 497     return last_name;
 498   }
 499   else
 500     return type->name;
 501 }
 502
 503 /*
 504    Set the clientdata field for a type
 505 */
 506 SWIGRUNTIME void
 507 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 508   swig_cast_info *cast = ti->cast;
 509   /* if (ti->clientdata == clientdata) return; */
 510   ti->clientdata = clientdata;
 511
 512   while (cast) {
 513     if (!cast->converter) {
 514       swig_type_info *tc = cast->type;
 515       if (!tc->clientdata) {
 516         SWIG_TypeClientData(tc, clientdata);
 517       }
 518     }
 519     cast = cast->next;
 520   }
 521 }
 522 SWIGRUNTIME void
 523 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 524   SWIG_TypeClientData(ti, clientdata);
 525   ti->owndata = 1;
 526 }
 527
 528 /*
 529   Search for a swig_type_info structure only by mangled name
 530   Search is a O(log #types)
 531
 532   We start searching at module start, and finish searching when start == end.
 533   Note: if start == end at the beginning of the function, we go all the way around
 534   the circular list.
 535 */
 536 SWIGRUNTIME swig_type_info *
 537 SWIG_MangledTypeQueryModule(swig_module_info *start,
 538                             swig_module_info *end,
 539                             const char *name) {
 540   swig_module_info *iter = start;
 541   do {
 542     if (iter->size) {
 543       register size_t l = 0;
 544       register size_t r = iter->size - 1;
 545       do {
 546         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 547         register size_t i = (l + r) >> 1;
 548         const char *iname = iter->types[i]->name;
 549         if (iname) {
 550           register int compare = strcmp(name, iname);
 551           if (compare == 0) {
 552             return iter->types[i];
 553           } else if (compare < 0) {
 554             if (i) {
 555               r = i - 1;
 556             } else {
 557               break;
 558             }
 559           } else if (compare > 0) {
 560             l = i + 1;
 561           }
 562         } else {
 563           break; /* should never happen */
 564         }
 565       } while (l <= r);
 566     }
 567     iter = iter->next;
 568   } while (iter != end);
 569   return 0;
 570 }
 571
 572 /*
 573   Search for a swig_type_info structure for either a mangled name or a human readable name.
 574   It first searches the mangled names of the types, which is a O(log #types)
 575   If a type is not found it then searches the human readable names, which is O(#types).
 576
 577   We start searching at module start, and finish searching when start == end.
 578   Note: if start == end at the beginning of the function, we go all the way around
 579   the circular list.
 580 */
 581 SWIGRUNTIME swig_type_info *
 582 SWIG_TypeQueryModule(swig_module_info *start,
 583                      swig_module_info *end,
 584                      const char *name) {
 585   /* STEP 1: Search the name field using binary search */
 586   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 587   if (ret) {
 588     return ret;
 589   } else {
 590     /* STEP 2: If the type hasn't been found, do a complete search
 591        of the str field (the human readable name) */
 592     swig_module_info *iter = start;
 593     do {
 594       register size_t i = 0;
 595       for (; i < iter->size; ++i) {
 596         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 597           return iter->types[i];
 598       }
 599       iter = iter->next;
 600     } while (iter != end);
 601   }
 602
 603   /* neither found a match */
 604   return 0;
 605 }
 606
 607 /*
 608    Pack binary data into a string
 609 */
 610 SWIGRUNTIME char *
 611 SWIG_PackData(char *c, void *ptr, size_t sz) {
 612   static const char hex[17] = "0123456789abcdef";
 613   register const unsigned char *u = (unsigned char *) ptr;
 614   register const unsigned char *eu =  u + sz;
 615   for (; u != eu; ++u) {
 616     register unsigned char uu = *u;
 617     *(c++) = hex[(uu & 0xf0) >> 4];
 618     *(c++) = hex[uu & 0xf];
 619   }
 620   return c;
 621 }
 622
 623 /*
 624    Unpack binary data from a string
 625 */
 626 SWIGRUNTIME const char *
 627 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 628   register unsigned char *u = (unsigned char *) ptr;
 629   register const unsigned char *eu = u + sz;
 630   for (; u != eu; ++u) {
 631     register char d = *(c++);
 632     register unsigned char uu;
 633     if ((d >= '0') && (d <= '9'))
 634       uu = ((d - '0') << 4);
 635     else if ((d >= 'a') && (d <= 'f'))
 636       uu = ((d - ('a'-10)) << 4);
 637     else
 638       return (char *) 0;
 639     d = *(c++);
 640     if ((d >= '0') && (d <= '9'))
 641       uu |= (d - '0');
 642     else if ((d >= 'a') && (d <= 'f'))
 643       uu |= (d - ('a'-10));
 644     else
 645       return (char *) 0;
 646     *u = uu;
 647   }
 648   return c;
 649 }
 650
 651 /*
 652    Pack 'void *' into a string buffer.
 653 */
 654 SWIGRUNTIME char *
 655 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 656   char *r = buff;
 657   if ((2*sizeof(void *) + 2) > bsz) return 0;
 658   *(r++) = '_';
 659   r = SWIG_PackData(r,&ptr,sizeof(void *));
 660   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 661   strcpy(r,name);
 662   return buff;
 663 }
 664
 665 SWIGRUNTIME const char *
 666 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 667   if (*c != '_') {
 668     if (strcmp(c,"NULL") == 0) {
 669       *ptr = (void *) 0;
 670       return name;
 671     } else {
 672       return 0;
 673     }
 674   }
 675   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 676 }
 677
 678 SWIGRUNTIME char *
 679 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 680   char *r = buff;
 681   size_t lname = (name ? strlen(name) : 0);
 682   if ((2*sz + 2 + lname) > bsz) return 0;
 683   *(r++) = '_';
 684   r = SWIG_PackData(r,ptr,sz);
 685   if (lname) {
 686     strncpy(r,name,lname+1);
 687   } else {
 688     *r = 0;
 689   }
 690   return buff;
 691 }
 692
 693 SWIGRUNTIME const char *
 694 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 695   if (*c != '_') {
 696     if (strcmp(c,"NULL") == 0) {
 697       memset(ptr,0,sz);
 698       return name;
 699     } else {
 700       return 0;
 701     }
 702   }
 703   return SWIG_UnpackData(++c,ptr,sz);
 704 }
 705
 706 #ifdef __cplusplus
 707 }
 708 #endif
 709
 710 /*  Errors in SWIG */
 711 #define  SWIG_UnknownError         -1
 712 #define  SWIG_IOError              -2
 713 #define  SWIG_RuntimeError         -3
 714 #define  SWIG_IndexError           -4
 715 #define  SWIG_TypeError            -5
 716 #define  SWIG_DivisionByZero       -6
 717 #define  SWIG_OverflowError        -7
 718 #define  SWIG_SyntaxError          -8
 719 #define  SWIG_ValueError           -9
 720 #define  SWIG_SystemError          -10
 721 #define  SWIG_AttributeError       -11
 722 #define  SWIG_MemoryError          -12
 723 #define  SWIG_NullReferenceError   -13
 724
 725
 726
 727 #ifdef __cplusplus
 728 /* Needed on some windows machines---since MS plays funny games with the header files under C++ */
 729 #include <math.h>
 730 #include <stdlib.h>
 731 extern "C" {
 732 #endif
 733 #include "EXTERN.h"
 734 #include "perl.h"
 735 #include "XSUB.h"
 736
 737 /* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
 738
 739 /* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
 740 #ifndef PERL_REVISION
 741 #  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
 742 #    define PERL_PATCHLEVEL_H_IMPLICIT
 743 #    include <patchlevel.h>
 744 #  endif
 745 #  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
 746 #    include <could_not_find_Perl_patchlevel.h>
 747 #  endif
 748 #  ifndef PERL_REVISION
 749 #    define PERL_REVISION       (5)
 750 #    define PERL_VERSION        PATCHLEVEL
 751 #    define PERL_SUBVERSION     SUBVERSION
 752 #  endif
 753 #endif
 754
 755 #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
 756 #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
 757 #endif
 758
 759 #ifndef SvIOK_UV
 760 # define SvIOK_UV(sv)       (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
 761 #endif
 762
 763 #ifndef SvUOK
 764 # define SvUOK(sv)           SvIOK_UV(sv)
 765 #endif
 766
 767 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
 768 #  define PL_sv_undef               sv_undef
 769 #  define PL_na                     na
 770 #  define PL_errgv                  errgv
 771 #  define PL_sv_no                  sv_no
 772 #  define PL_sv_yes                 sv_yes
 773 #  define PL_markstack_ptr          markstack_ptr
 774 #endif
 775
 776 #ifndef IVSIZE
 777 #  ifdef LONGSIZE
 778 #    define IVSIZE LONGSIZE
 779 #  else
 780 #    define IVSIZE 4 /* A bold guess, but the best we can make. */
 781 #  endif
 782 #endif
 783
 784 #ifndef INT2PTR
 785 #  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
 786 #    define PTRV                  UV
 787 #    define INT2PTR(any,d)        (any)(d)
 788 #  else
 789 #    if PTRSIZE == LONGSIZE
 790 #      define PTRV                unsigned long
 791 #    else
 792 #      define PTRV                unsigned
 793 #    endif
 794 #    define INT2PTR(any,d)        (any)(PTRV)(d)
 795 #  endif
 796
 797 #  define NUM2PTR(any,d)  (any)(PTRV)(d)
 798 #  define PTR2IV(p)       INT2PTR(IV,p)
 799 #  define PTR2UV(p)       INT2PTR(UV,p)
 800 #  define PTR2NV(p)       NUM2PTR(NV,p)
 801
 802 #  if PTRSIZE == LONGSIZE
 803 #    define PTR2ul(p)     (unsigned long)(p)
 804 #  else
 805 #    define PTR2ul(p)     INT2PTR(unsigned long,p)
 806 #  endif
 807 #endif /* !INT2PTR */
 808
 809 #ifndef SvPV_nolen
 810 # define SvPV_nolen(x) SvPV(x,PL_na)
 811 #endif
 812
 813 #ifndef get_sv
 814 #  define get_sv perl_get_sv
 815 #endif
 816
 817 #ifndef ERRSV
 818 #  define ERRSV get_sv("@",FALSE)
 819 #endif
 820
 821 #ifndef pTHX_
 822 #define pTHX_
 823 #endif
 824
 825 #include <string.h>
 826 #ifdef __cplusplus
 827 }
 828 #endif
 829
 830 /* -----------------------------------------------------------------------------
 831  * error manipulation
 832  * ----------------------------------------------------------------------------- */
 833
 834 SWIGINTERN const char*
 835 SWIG_Perl_ErrorType(int code) {
 836   const char* type = 0;
 837   switch(code) {
 838   case SWIG_MemoryError:
 839     type = "MemoryError";
 840     break;
 841   case SWIG_IOError:
 842     type = "IOError";
 843     break;
 844   case SWIG_RuntimeError:
 845     type = "RuntimeError";
 846     break;
 847   case SWIG_IndexError:
 848     type = "IndexError";
 849     break;
 850   case SWIG_TypeError:
 851     type = "TypeError";
 852     break;
 853   case SWIG_DivisionByZero:
 854     type = "ZeroDivisionError";
 855     break;
 856   case SWIG_OverflowError:
 857     type = "OverflowError";
 858     break;
 859   case SWIG_SyntaxError:
 860     type = "SyntaxError";
 861     break;
 862   case SWIG_ValueError:
 863     type = "ValueError";
 864     break;
 865   case SWIG_SystemError:
 866     type = "SystemError";
 867     break;
 868   case SWIG_AttributeError:
 869     type = "AttributeError";
 870     break;
 871   default:
 872     type = "RuntimeError";
 873   }
 874   return type;
 875 }
 876
 877
 878
 879
 880 /* -----------------------------------------------------------------------------
 881  * perlrun.swg
 882  *
 883  * This file contains the runtime support for Perl modules
 884  * and includes code for managing global variables and pointer
 885  * type checking.
 886  * ----------------------------------------------------------------------------- */
 887
 888 #ifdef PERL_OBJECT
 889 #define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
 890 #define SWIG_PERL_OBJECT_CALL pPerl,
 891 #else
 892 #define SWIG_PERL_OBJECT_DECL
 893 #define SWIG_PERL_OBJECT_CALL
 894 #endif
 895
 896 /* Common SWIG API */
 897
 898 /* for raw pointers */
 899 #define SWIG_ConvertPtr(obj, pp, type, flags)           SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
 900 #define SWIG_NewPointerObj(p, type, flags)              SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
 901
 902 /* for raw packed data */
 903 #define SWIG_ConvertPacked(obj, p, s, type)             SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
 904 #define SWIG_NewPackedObj(p, s, type)                   SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
 905
 906 /* for class or struct pointers */
 907 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
 908 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
 909
 910 /* for C or C++ function pointers */
 911 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
 912 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
 913
 914 /* for C++ member pointers, ie, member methods */
 915 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_ConvertPacked(obj, ptr, sz, ty)
 916 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_NewPackedObj(ptr, sz, type)
 917
 918
 919 /* Runtime API */
 920
 921 #define SWIG_GetModule(clientdata)                      SWIG_Perl_GetModule()
 922 #define SWIG_SetModule(clientdata, pointer)             SWIG_Perl_SetModule(pointer)
 923
 924
 925 /* Error manipulation */
 926
 927 #define SWIG_ErrorType(code)                            SWIG_Perl_ErrorType(code)
 928 #define SWIG_Error(code, msg)                           sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg)
 929 #define SWIG_fail                                       goto fail
 930
 931 /* Perl-specific SWIG API */
 932
 933 #define SWIG_MakePtr(sv, ptr, type, flags)              SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
 934 #define SWIG_MakePackedObj(sv, p, s, type)              SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
 935 #define SWIG_SetError(str)                              SWIG_Error(SWIG_RuntimeError, str)
 936
 937
 938 #define SWIG_PERL_DECL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_DECL arg1)
 939 #define SWIG_PERL_CALL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_CALL arg1)
 940 #define SWIG_PERL_DECL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_DECL arg1, arg2)
 941 #define SWIG_PERL_CALL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_CALL arg1, arg2)
 942
 943 /* -----------------------------------------------------------------------------
 944  * pointers/data manipulation
 945  * ----------------------------------------------------------------------------- */
 946
 947 /* For backward compatibility only */
 948 #define SWIG_POINTER_EXCEPTION  0
 949
 950 #ifdef __cplusplus
 951 extern "C" {
 952 #endif
 953
 954 #define SWIG_OWNER   SWIG_POINTER_OWN
 955 #define SWIG_SHADOW  SWIG_OWNER << 1
 956
 957 #define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
 958
 959 /* SWIG Perl macros */
 960
 961 /* Macro to declare an XS function */
 962 #ifndef XSPROTO
 963 #   define XSPROTO(name) void name(pTHX_ CV* cv)
 964 #endif
 965
 966 /* Macro to call an XS function */
 967 #ifdef PERL_OBJECT
 968 #  define SWIG_CALLXS(_name) _name(cv,pPerl)
 969 #else
 970 #  ifndef MULTIPLICITY
 971 #    define SWIG_CALLXS(_name) _name(cv)
 972 #  else
 973 #    define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
 974 #  endif
 975 #endif
 976
 977 #ifdef PERL_OBJECT
 978 #define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
 979
 980 #ifdef __cplusplus
 981 extern "C" {
 982 #endif
 983 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
 984 #ifdef __cplusplus
 985 }
 986 #endif
 987
 988 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
 989 #define SWIGCLASS_STATIC
 990
 991 #else /* PERL_OBJECT */
 992
 993 #define MAGIC_PPERL
 994 #define SWIGCLASS_STATIC static SWIGUNUSED
 995
 996 #ifndef MULTIPLICITY
 997 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
 998
 999 #ifdef __cplusplus
1000 extern "C" {
1001 #endif
1002 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
1003 #ifdef __cplusplus
1004 }
1005 #endif
1006
1007 #else /* MULTIPLICITY */
1008
1009 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
1010
1011 #ifdef __cplusplus
1012 extern "C" {
1013 #endif
1014 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
1015 #ifdef __cplusplus
1016 }
1017 #endif
1018
1019 #endif /* MULTIPLICITY */
1020 #endif /* PERL_OBJECT */
1021
1022 /* Workaround for bug in perl 5.6.x croak and earlier */
1023 #if (PERL_VERSION < 8)
1024 #  ifdef PERL_OBJECT
1025 #    define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
1026 static void SWIG_Perl_croak_null(CPerlObj *pPerl)
1027 #  else
1028 static void SWIG_croak_null()
1029 #  endif
1030 {
1031   SV *err=ERRSV;
1032 #  if (PERL_VERSION < 6)
1033   croak("%_", err);
1034 #  else
1035   if (SvOK(err) && !SvROK(err)) croak("%_", err);
1036   croak(Nullch);
1037 #  endif
1038 }
1039 #else
1040 #  define SWIG_croak_null() croak(Nullch)
1041 #endif
1042
1043
1044 /*
1045    Define how strict is the cast between strings and integers/doubles
1046    when overloading between these types occurs.
1047
1048    The default is making it as strict as possible by using SWIG_AddCast
1049    when needed.
1050
1051    You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
1052    disable the SWIG_AddCast, making the casting between string and
1053    numbers less strict.
1054
1055    In the end, we try to solve the overloading between strings and
1056    numerical types in the more natural way, but if you can avoid it,
1057    well, avoid it using %rename, for example.
1058 */
1059 #ifndef SWIG_PERL_NO_STRICT_STR2NUM
1060 # ifndef SWIG_PERL_STRICT_STR2NUM
1061 #  define SWIG_PERL_STRICT_STR2NUM
1062 # endif
1063 #endif
1064 #ifdef SWIG_PERL_STRICT_STR2NUM
1065 /* string takes precedence */
1066 #define SWIG_Str2NumCast(x) SWIG_AddCast(x)
1067 #else
1068 /* number takes precedence */
1069 #define SWIG_Str2NumCast(x) x
1070 #endif
1071
1072
1073
1074 #include <stdlib.h>
1075
1076 SWIGRUNTIME const char *
1077 SWIG_Perl_TypeProxyName(const swig_type_info *type) {
1078   if (!type) return NULL;
1079   if (type->clientdata != NULL) {
1080     return (const char*) type->clientdata;
1081   }
1082   else {
1083     return type->name;
1084   }
1085 }
1086
1087 /* Identical to SWIG_TypeCheck, except for strcmp comparison */
1088 SWIGRUNTIME swig_cast_info *
1089 SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
1090   if (ty) {
1091     swig_cast_info *iter = ty->cast;
1092     while (iter) {
1093       if ( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0)) ||
1094             (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0)) ) {
1095         if (iter == ty->cast)
1096           return iter;
1097         /* Move iter to the top of the linked list */
1098         iter->prev->next = iter->next;
1099         if (iter->next)
1100           iter->next->prev = iter->prev;
1101         iter->next = ty->cast;
1102         iter->prev = 0;
1103         if (ty->cast) ty->cast->prev = iter;
1104         ty->cast = iter;
1105         return iter;
1106       }
1107       iter = iter->next;
1108     }
1109   }
1110   return 0;
1111 }
1112
1113 /* Function for getting a pointer value */
1114
1115 SWIGRUNTIME int
1116 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
1117   swig_cast_info *tc;
1118   void *voidptr = (void *)0;
1119   SV *tsv = 0;
1120   /* If magical, apply more magic */
1121   if (SvGMAGICAL(sv))
1122     mg_get(sv);
1123
1124   /* Check to see if this is an object */
1125   if (sv_isobject(sv)) {
1126     IV tmp = 0;
1127     tsv = (SV*) SvRV(sv);
1128     if ((SvTYPE(tsv) == SVt_PVHV)) {
1129       MAGIC *mg;
1130       if (SvMAGICAL(tsv)) {
1131         mg = mg_find(tsv,'P');
1132         if (mg) {
1133           sv = mg->mg_obj;
1134           if (sv_isobject(sv)) {
1135             tsv = (SV*)SvRV(sv);
1136             tmp = SvIV(tsv);
1137           }
1138         }
1139       } else {
1140         return SWIG_ERROR;
1141       }
1142     } else {
1143       tmp = SvIV(tsv);
1144     }
1145     voidptr = INT2PTR(void *,tmp);
1146   } else if (! SvOK(sv)) {            /* Check for undef */
1147     *(ptr) = (void *) 0;
1148     return SWIG_OK;
1149   } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
1150     if (!SvROK(sv)) {
1151       *(ptr) = (void *) 0;
1152       return SWIG_OK;
1153     } else {
1154       return SWIG_ERROR;
1155     }
1156   } else {                            /* Don't know what it is */
1157     return SWIG_ERROR;
1158   }
1159   if (_t) {
1160     /* Now see if the types match */
1161     char *_c = HvNAME(SvSTASH(SvRV(sv)));
1162     tc = SWIG_TypeProxyCheck(_c,_t);
1163     if (!tc) {
1164       return SWIG_ERROR;
1165     }
1166     {
1167       int newmemory = 0;
1168       *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
1169       assert(!newmemory); /* newmemory handling not yet implemented */
1170     }
1171   } else {
1172     *ptr = voidptr;
1173   }
1174
1175   /*
1176    *  DISOWN implementation: we need a perl guru to check this one.
1177    */
1178   if (tsv && (flags & SWIG_POINTER_DISOWN)) {
1179     /*
1180      *  almost copy paste code from below SWIG_POINTER_OWN setting
1181      */
1182     SV *obj = sv;
1183     HV *stash = SvSTASH(SvRV(obj));
1184     GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
1185     if (isGV(gv)) {
1186       HV *hv = GvHVn(gv);
1187       /*
1188        * To set ownership (see below), a newSViv(1) entry is added.
1189        * Hence, to remove ownership, we delete the entry.
1190        */
1191       if (hv_exists_ent(hv, obj, 0)) {
1192         hv_delete_ent(hv, obj, 0, 0);
1193       }
1194     }
1195   }
1196   return SWIG_OK;
1197 }
1198
1199 SWIGRUNTIME void
1200 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
1201   if (ptr && (flags & SWIG_SHADOW)) {
1202     SV *self;
1203     SV *obj=newSV(0);
1204     HV *hash=newHV();
1205     HV *stash;
1206     sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1207     stash=SvSTASH(SvRV(obj));
1208     if (flags & SWIG_POINTER_OWN) {
1209       HV *hv;
1210       GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1211       if (!isGV(gv))
1212         gv_init(gv, stash, "OWNER", 5, FALSE);
1213       hv=GvHVn(gv);
1214       hv_store_ent(hv, obj, newSViv(1), 0);
1215     }
1216     sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
1217     SvREFCNT_dec(obj);
1218     self=newRV_noinc((SV *)hash);
1219     sv_setsv(sv, self);
1220     SvREFCNT_dec((SV *)self);
1221     sv_bless(sv, stash);
1222   }
1223   else {
1224     sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1225   }
1226 }
1227
1228 SWIGRUNTIMEINLINE SV *
1229 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
1230   SV *result = sv_newmortal();
1231   SWIG_MakePtr(result, ptr, t, flags);
1232   return result;
1233 }
1234
1235 SWIGRUNTIME void
1236 SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
1237   char result[1024];
1238   char *r = result;
1239   if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
1240   *(r++) = '_';
1241   r = SWIG_PackData(r,ptr,sz);
1242   strcpy(r,SWIG_Perl_TypeProxyName(type));
1243   sv_setpv(sv, result);
1244 }
1245
1246 SWIGRUNTIME SV *
1247 SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
1248   SV *result = sv_newmortal();
1249   SWIG_Perl_MakePackedObj(result, ptr, sz, type);
1250   return result;
1251 }
1252
1253 /* Convert a packed value value */
1254 SWIGRUNTIME int
1255 SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
1256   swig_cast_info *tc;
1257   const char  *c = 0;
1258
1259   if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
1260   c = SvPV_nolen(obj);
1261   /* Pointer values must start with leading underscore */
1262   if (*c != '_') return SWIG_ERROR;
1263   c++;
1264   c = SWIG_UnpackData(c,ptr,sz);
1265   if (ty) {
1266     tc = SWIG_TypeCheck(c,ty);
1267     if (!tc) return SWIG_ERROR;
1268   }
1269   return SWIG_OK;
1270 }
1271
1272
1273 /* Macros for low-level exception handling */
1274 #define SWIG_croak(x)    { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
1275
1276
1277 typedef XSPROTO(SwigPerlWrapper);
1278 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
1279
1280 /* Structure for command table */
1281 typedef struct {
1282   const char         *name;
1283   SwigPerlWrapperPtr  wrapper;
1284 } swig_command_info;
1285
1286 /* Information for constant table */
1287
1288 #define SWIG_INT     1
1289 #define SWIG_FLOAT   2
1290 #define SWIG_STRING  3
1291 #define SWIG_POINTER 4
1292 #define SWIG_BINARY  5
1293
1294 /* Constant information structure */
1295 typedef struct swig_constant_info {
1296     int              type;
1297     const char      *name;
1298     long             lvalue;
1299     double           dvalue;
1300     void            *pvalue;
1301     swig_type_info **ptype;
1302 } swig_constant_info;
1303
1304
1305 /* Structure for variable table */
1306 typedef struct {
1307   const char   *name;
1308   SwigMagicFunc   set;
1309   SwigMagicFunc   get;
1310   swig_type_info  **type;
1311 } swig_variable_info;
1312
1313 /* Magic variable code */
1314 #ifndef PERL_OBJECT
1315 #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
1316   #ifndef MULTIPLICITY
1317      SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
1318   #else
1319      SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
1320   #endif
1321 #else
1322 #  define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
1323 SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
1324 #endif
1325 {
1326   MAGIC *mg;
1327   sv_magic(sv,sv,'U',(char *) name,strlen(name));
1328   mg = mg_find(sv,'U');
1329   mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
1330   mg->mg_virtual->svt_get = (SwigMagicFunc) get;
1331   mg->mg_virtual->svt_set = (SwigMagicFunc) set;
1332   mg->mg_virtual->svt_len = 0;
1333   mg->mg_virtual->svt_clear = 0;
1334   mg->mg_virtual->svt_free = 0;
1335 }
1336
1337
1338 SWIGRUNTIME swig_module_info *
1339 SWIG_Perl_GetModule(void) {
1340   static void *type_pointer = (void *)0;
1341   SV *pointer;
1342
1343   /* first check if pointer already created */
1344   if (!type_pointer) {
1345     pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
1346     if (pointer && SvOK(pointer)) {
1347       type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
1348     }
1349   }
1350
1351   return (swig_module_info *) type_pointer;
1352 }
1353
1354 SWIGRUNTIME void
1355 SWIG_Perl_SetModule(swig_module_info *module) {
1356   SV *pointer;
1357
1358   /* create a new pointer */
1359   pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
1360   sv_setiv(pointer, PTR2IV(module));
1361 }
1362
1363 #ifdef __cplusplus
1364 }
1365 #endif
1366
1367 /* Workaround perl5 global namespace pollution. Note that undefining library
1368  * functions like fopen will not solve the problem on all platforms as fopen
1369  * might be a macro on Windows but not necessarily on other operating systems. */
1370 #ifdef do_open
1371   #undef do_open
1372 #endif
1373 #ifdef do_close
1374   #undef do_close
1375 #endif
1376 #ifdef scalar
1377   #undef scalar
1378 #endif
1379 #ifdef list
1380   #undef list
1381 #endif
1382 #ifdef apply
1383   #undef apply
1384 #endif
1385 #ifdef convert
1386   #undef convert
1387 #endif
1388 #ifdef Error
1389   #undef Error
1390 #endif
1391 #ifdef form
1392   #undef form
1393 #endif
1394 #ifdef vform
1395   #undef vform
1396 #endif
1397 #ifdef LABEL
1398   #undef LABEL
1399 #endif
1400 #ifdef METHOD
1401   #undef METHOD
1402 #endif
1403 #ifdef Move
1404   #undef Move
1405 #endif
1406 #ifdef yylex
1407   #undef yylex
1408 #endif
1409 #ifdef yyparse
1410   #undef yyparse
1411 #endif
1412 #ifdef yyerror
1413   #undef yyerror
1414 #endif
1415 #ifdef invert
1416   #undef invert
1417 #endif
1418 #ifdef ref
1419   #undef ref
1420 #endif
1421 #ifdef read
1422   #undef read
1423 #endif
1424 #ifdef write
1425   #undef write
1426 #endif
1427 #ifdef eof
1428   #undef eof
1429 #endif
1430 #ifdef bool
1431   #undef bool
1432 #endif
1433 #ifdef close
1434   #undef close
1435 #endif
1436 #ifdef rewind
1437   #undef rewind
1438 #endif
1439 #ifdef free
1440   #undef free
1441 #endif
1442 #ifdef malloc
1443   #undef malloc
1444 #endif
1445 #ifdef calloc
1446   #undef calloc
1447 #endif
1448 #ifdef Stat
1449   #undef Stat
1450 #endif
1451 #ifdef check
1452   #undef check
1453 #endif
1454 #ifdef seekdir
1455   #undef seekdir
1456 #endif
1457 #ifdef open
1458   #undef open
1459 #endif
1460 #ifdef readdir
1461   #undef readdir
1462 #endif
1463 #ifdef bind
1464   #undef bind
1465 #endif
1466
1467
1468
1469 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1470
1471 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1472
1473
1474
1475   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
1476
1477
1478 /* -------- TYPES TABLE (BEGIN) -------- */
1479
1480 #define SWIGTYPE_p_a_STRMAX__char swig_types[0]
1481 #define SWIGTYPE_p_char swig_types[1]
1482 #define SWIGTYPE_p_double swig_types[2]
1483 #define SWIGTYPE_p_dumpfile_t swig_types[3]
1484 #define SWIGTYPE_p_float swig_types[4]
1485 #define SWIGTYPE_p_int swig_types[5]
1486 #define SWIGTYPE_p_off_t swig_types[6]
1487 #define SWIGTYPE_p_unsigned_char swig_types[7]
1488 static swig_type_info *swig_types[9];
1489 static swig_module_info swig_module = {swig_types, 8, 0, 0, 0, 0};
1490 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1491 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1492
1493 /* -------- TYPES TABLE (END) -------- */
1494
1495 #define SWIG_init    boot_Amanda__Header
1496
1497 #define SWIG_name   "Amanda::Headerc::boot_Amanda__Header"
1498 #define SWIG_prefix "Amanda::Headerc::"
1499
1500 #define SWIGVERSION 0x010339
1501 #define SWIG_VERSION SWIGVERSION
1502
1503
1504 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1505 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1506
1507
1508 #ifdef __cplusplus
1509 extern "C"
1510 #endif
1511 #ifndef PERL_OBJECT
1512 #ifndef MULTIPLICITY
1513 SWIGEXPORT void SWIG_init (CV* cv);
1514 #else
1515 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1516 #endif
1517 #else
1518 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1519 #endif
1520
1521
1522 #include "amglue.h"
1523
1524
1525 #include "amglue.h"
1526
1527
1528 #include "amglue.h"
1529
1530
1531 #include "fileheader.h"
1532
1533
1534 SWIGINTERNINLINE SV *
1535 SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
1536 {
1537   SV *obj = sv_newmortal();
1538   sv_setiv(obj, (IV) value);
1539   return obj;
1540 }
1541
1542
1543 SWIGINTERNINLINE SV *
1544 SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
1545 {
1546   return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
1547 }
1548
1549
1550 #include <limits.h>
1551 #if !defined(SWIG_NO_LLONG_MAX)
1552 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1553 #   define LLONG_MAX __LONG_LONG_MAX__
1554 #   define LLONG_MIN (-LLONG_MAX - 1LL)
1555 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1556 # endif
1557 #endif
1558
1559
1560 SWIGINTERN int
1561 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1562 {
1563   if (SvNIOK(obj)) {
1564     if (val) *val = SvNV(obj);
1565     return SWIG_OK;
1566   } else if (SvIOK(obj)) {
1567     if (val) *val = (double) SvIV(obj);
1568     return SWIG_AddCast(SWIG_OK);
1569   } else {
1570     const char *nptr = SvPV_nolen(obj);
1571     if (nptr) {
1572       char *endptr;
1573       double v = strtod(nptr, &endptr);
1574       if (errno == ERANGE) {
1575         errno = 0;
1576         return SWIG_OverflowError;
1577       } else {
1578         if (*endptr == '\0') {
1579           if (val) *val = v;
1580           return SWIG_Str2NumCast(SWIG_OK);
1581         }
1582       }
1583     }
1584   }
1585   return SWIG_TypeError;
1586 }
1587
1588
1589 #include <float.h>
1590
1591
1592 #include <math.h>
1593
1594
1595 SWIGINTERNINLINE int
1596 SWIG_CanCastAsInteger(double *d, double min, double max) {
1597   double x = *d;
1598   if ((min <= x && x <= max)) {
1599    double fx = floor(x);
1600    double cx = ceil(x);
1601    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1602    if ((errno == EDOM) || (errno == ERANGE)) {
1603      errno = 0;
1604    } else {
1605      double summ, reps, diff;
1606      if (rd < x) {
1607        diff = x - rd;
1608      } else if (rd > x) {
1609        diff = rd - x;
1610      } else {
1611        return 1;
1612      }
1613      summ = rd + x;
1614      reps = diff/summ;
1615      if (reps < 8*DBL_EPSILON) {
1616        *d = rd;
1617        return 1;
1618      }
1619    }
1620   }
1621   return 0;
1622 }
1623
1624
1625 SWIGINTERN int
1626 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1627 {
1628   if (SvIOK(obj)) {
1629     if (val) *val = SvIV(obj);
1630     return SWIG_OK;
1631   } else {
1632     int dispatch = 0;
1633     const char *nptr = SvPV_nolen(obj);
1634     if (nptr) {
1635       char *endptr;
1636       long v;
1637       errno = 0;
1638       v = strtol(nptr, &endptr,0);
1639       if (errno == ERANGE) {
1640         errno = 0;
1641         return SWIG_OverflowError;
1642       } else {
1643         if (*endptr == '\0') {
1644           if (val) *val = v;
1645           return SWIG_Str2NumCast(SWIG_OK);
1646         }
1647       }
1648     }
1649     if (!dispatch) {
1650       double d;
1651       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1652       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1653         if (val) *val = (long)(d);
1654         return res;
1655       }
1656     }
1657   }
1658   return SWIG_TypeError;
1659 }
1660
1661
1662 SWIGINTERN int
1663 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1664 {
1665   long v;
1666   int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1667   if (SWIG_IsOK(res)) {
1668     if ((v < INT_MIN || v > INT_MAX)) {
1669       return SWIG_OverflowError;
1670     } else {
1671       if (val) *val = (int)(v);
1672     }
1673   }
1674   return res;
1675 }
1676
1677
1678 SWIGINTERN swig_type_info*
1679 SWIG_pchar_descriptor(void)
1680 {
1681   static int init = 0;
1682   static swig_type_info* info = 0;
1683   if (!init) {
1684     info = SWIG_TypeQuery("_p_char");
1685     init = 1;
1686   }
1687   return info;
1688 }
1689
1690
1691 SWIGINTERN int
1692 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1693 {
1694   if (SvMAGICAL(obj)) {
1695      SV *tmp = sv_newmortal();
1696      SvSetSV(tmp, obj);
1697      obj = tmp;
1698   }
1699   if (SvPOK(obj)) {
1700     STRLEN len = 0;
1701     char *cstr = SvPV(obj, len);
1702     size_t size = len + 1;
1703     if (cptr)  {
1704       if (alloc) {
1705         if (*alloc == SWIG_NEWOBJ) {
1706           *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1707         } else {
1708           *cptr = cstr;
1709           *alloc = SWIG_OLDOBJ;
1710         }
1711       }
1712     }
1713     if (psize) *psize = size;
1714     return SWIG_OK;
1715   } else {
1716     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1717     if (pchar_descriptor) {
1718       char* vptr = 0;
1719       if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1720         if (cptr) *cptr = vptr;
1721         if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1722         if (alloc) *alloc = SWIG_OLDOBJ;
1723         return SWIG_OK;
1724       }
1725     }
1726   }
1727   return SWIG_TypeError;
1728 }
1729
1730
1731 SWIGINTERN int
1732 SWIG_AsCharArray(SV * obj, char *val, size_t size)
1733 {
1734   char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
1735   int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
1736   if (SWIG_IsOK(res)) {
1737     if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
1738     if (csize <= size) {
1739       if (val) {
1740         if (csize) memcpy(val, cptr, csize*sizeof(char));
1741         if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
1742       }
1743       if (alloc == SWIG_NEWOBJ) {
1744         free((char*)cptr);
1745         res = SWIG_DelNewMask(res);
1746       }
1747       return res;
1748     }
1749     if (alloc == SWIG_NEWOBJ) free((char*)cptr);
1750   }
1751   return SWIG_TypeError;
1752 }
1753
1754
1755 SWIGINTERNINLINE SV *
1756 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1757 {
1758   SV *obj = sv_newmortal();
1759   if (carray) {
1760     sv_setpvn(obj, carray, size);
1761   } else {
1762     sv_setsv(obj, &PL_sv_undef);
1763   }
1764   return obj;
1765 }
1766
1767
1768
1769
1770
1771 SWIGINTERNINLINE SV *
1772 SWIG_FromCharPtr(const char *cptr)
1773 {
1774   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1775 }
1776
1777
1778 SWIGINTERN int
1779 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
1780 {
1781   if (SvUOK(obj)) {
1782     if (val) *val = SvUV(obj);
1783     return SWIG_OK;
1784   } else  if (SvIOK(obj)) {
1785     long v = SvIV(obj);
1786     if (v >= 0) {
1787       if (val) *val = v;
1788       return SWIG_OK;
1789     } else {
1790       return SWIG_OverflowError;
1791     }
1792   } else {
1793     int dispatch = 0;
1794     const char *nptr = SvPV_nolen(obj);
1795     if (nptr) {
1796       char *endptr;
1797       unsigned long v;
1798       errno = 0;
1799       v = strtoul(nptr, &endptr,0);
1800       if (errno == ERANGE) {
1801         errno = 0;
1802         return SWIG_OverflowError;
1803       } else {
1804         if (*endptr == '\0') {
1805           if (val) *val = v;
1806           return SWIG_Str2NumCast(SWIG_OK);
1807         }
1808       }
1809     }
1810     if (!dispatch) {
1811       double d;
1812       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1813       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
1814         if (val) *val = (unsigned long)(d);
1815         return res;
1816       }
1817     }
1818   }
1819   return SWIG_TypeError;
1820 }
1821
1822
1823 SWIGINTERNINLINE int
1824 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
1825 {
1826   unsigned long v;
1827   int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
1828   if (SWIG_IsOK(res) && val) *val = (size_t)(v);
1829   return res;
1830 }
1831
1832 SWIGINTERN dumpfile_t *new_dumpfile_t(){
1833             dumpfile_t *df = g_new(dumpfile_t, 1);
1834             fh_init(df);
1835             /* some default values */
1836             df->totalparts = -1;
1837             df->partnum = 1;
1838             return df;
1839         }
1840 SWIGINTERN SV *dumpfile_t_to_string(dumpfile_t *self,size_t min_size,size_t max_size){
1841             size_t size = min_size;
1842             char *result;
1843
1844             result = build_header(self, &size, max_size);
1845             if (!result) {
1846                 /* header didn't fit -> return undef; */
1847                 return &PL_sv_undef;
1848             } else {
1849                 STRLEN strlen_size = (STRLEN)size;
1850                 SV *sv;
1851                 g_assert((size_t)strlen_size == size); /* check for casting overflow */
1852                 sv = sv_2mortal(newSVpvn(result, (STRLEN)size));
1853                 g_free(result);
1854                 return sv;
1855             }
1856         }
1857 SWIGINTERN void dumpfile_t_debug_dump(dumpfile_t *self){
1858             dump_dumpfile_t(self);
1859         }
1860 SWIGINTERN char *dumpfile_t_summary(dumpfile_t *self){
1861             return summarize_header(self);
1862         }
1863
1864 static dumpfile_t *C_from_string(const char *string) {
1865     dumpfile_t *result = g_new(dumpfile_t, 1);
1866     parse_file_header(string, result, strlen(string));
1867     return result;
1868 }
1869
1870 #ifdef __cplusplus
1871 extern "C" {
1872 #endif
1873
1874 #ifdef PERL_OBJECT
1875 #define MAGIC_CLASS _wrap_Amanda__Header_var::
1876 class _wrap_Amanda__Header_var : public CPerlObj {
1877 public:
1878 #else
1879 #define MAGIC_CLASS
1880 #endif
1881 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
1882     MAGIC_PPERL
1883     croak("Value is read-only.");
1884     return 0;
1885 }
1886
1887
1888 #ifdef PERL_OBJECT
1889 };
1890 #endif
1891
1892 #ifdef __cplusplus
1893 }
1894 #endif
1895
1896 #ifdef __cplusplus
1897 extern "C" {
1898 #endif
1899 XS(_wrap_Header_type_set) {
1900   {
1901     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1902     filetype_t arg2 ;
1903     void *argp1 = 0 ;
1904     int res1 = 0 ;
1905     int argvi = 0;
1906     dXSARGS;
1907
1908     if ((items < 2) || (items > 2)) {
1909       SWIG_croak("Usage: Header_type_set(self,type);");
1910     }
1911     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
1912     if (!SWIG_IsOK(res1)) {
1913       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_type_set" "', argument " "1"" of type '" "dumpfile_t *""'");
1914     }
1915     arg1 = (dumpfile_t *)(argp1);
1916     {
1917       if (sizeof(signed int) == 1) {
1918         arg2 = amglue_SvI8(ST(1));
1919       } else if (sizeof(signed int) == 2) {
1920         arg2 = amglue_SvI16(ST(1));
1921       } else if (sizeof(signed int) == 4) {
1922         arg2 = amglue_SvI32(ST(1));
1923       } else if (sizeof(signed int) == 8) {
1924         arg2 = amglue_SvI64(ST(1));
1925       } else {
1926         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
1927       }
1928     }
1929     if (arg1) (arg1)->type = arg2;
1930     ST(argvi) = sv_newmortal();
1931
1932
1933     XSRETURN(argvi);
1934   fail:
1935
1936
1937     SWIG_croak_null();
1938   }
1939 }
1940
1941
1942 XS(_wrap_Header_type_get) {
1943   {
1944     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1945     void *argp1 = 0 ;
1946     int res1 = 0 ;
1947     int argvi = 0;
1948     filetype_t result;
1949     dXSARGS;
1950
1951     if ((items < 1) || (items > 1)) {
1952       SWIG_croak("Usage: Header_type_get(self);");
1953     }
1954     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
1955     if (!SWIG_IsOK(res1)) {
1956       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_type_get" "', argument " "1"" of type '" "dumpfile_t *""'");
1957     }
1958     arg1 = (dumpfile_t *)(argp1);
1959     result = (filetype_t) ((arg1)->type);
1960     {
1961       SV *for_stack;
1962       SP += argvi; PUTBACK;
1963       for_stack = sv_2mortal(amglue_newSVi64(result));
1964       SPAGAIN; SP -= argvi;
1965       ST(argvi) = for_stack;
1966       argvi++;
1967     }
1968
1969     XSRETURN(argvi);
1970   fail:
1971
1972     SWIG_croak_null();
1973   }
1974 }
1975
1976
1977 XS(_wrap_Header_datestamp_set) {
1978   {
1979     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1980     char *arg2 ;
1981     void *argp1 = 0 ;
1982     int res1 = 0 ;
1983     char temp2[STRMAX] ;
1984     int res2 ;
1985     int argvi = 0;
1986     dXSARGS;
1987
1988     if ((items < 2) || (items > 2)) {
1989       SWIG_croak("Usage: Header_datestamp_set(self,datestamp);");
1990     }
1991     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
1992     if (!SWIG_IsOK(res1)) {
1993       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_datestamp_set" "', argument " "1"" of type '" "dumpfile_t *""'");
1994     }
1995     arg1 = (dumpfile_t *)(argp1);
1996     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
1997     if (!SWIG_IsOK(res2)) {
1998       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_datestamp_set" "', argument " "2"" of type '" "char [STRMAX]""'");
1999     }
2000     arg2 = (char *)(temp2);
2001     {
2002       strncpy(arg1->datestamp, arg2, STRMAX);
2003       if (arg1->datestamp[STRMAX-1] != '\0')
2004       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2005     }
2006     ST(argvi) = sv_newmortal();
2007
2008
2009     XSRETURN(argvi);
2010   fail:
2011
2012
2013     SWIG_croak_null();
2014   }
2015 }
2016
2017
2018 XS(_wrap_Header_datestamp_get) {
2019   {
2020     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2021     void *argp1 = 0 ;
2022     int res1 = 0 ;
2023     int argvi = 0;
2024     char *result = 0 ;
2025     dXSARGS;
2026
2027     if ((items < 1) || (items > 1)) {
2028       SWIG_croak("Usage: Header_datestamp_get(self);");
2029     }
2030     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2031     if (!SWIG_IsOK(res1)) {
2032       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_datestamp_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2033     }
2034     arg1 = (dumpfile_t *)(argp1);
2035     result = (char *) ((arg1)->datestamp);
2036     {
2037       size_t size = STRMAX;
2038
2039       while (size && (result[size - 1] == '\0')) --size;
2040
2041       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2042     }
2043
2044     XSRETURN(argvi);
2045   fail:
2046
2047     SWIG_croak_null();
2048   }
2049 }
2050
2051
2052 XS(_wrap_Header_dumplevel_set) {
2053   {
2054     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2055     int arg2 ;
2056     void *argp1 = 0 ;
2057     int res1 = 0 ;
2058     int argvi = 0;
2059     dXSARGS;
2060
2061     if ((items < 2) || (items > 2)) {
2062       SWIG_croak("Usage: Header_dumplevel_set(self,dumplevel);");
2063     }
2064     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2065     if (!SWIG_IsOK(res1)) {
2066       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dumplevel_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2067     }
2068     arg1 = (dumpfile_t *)(argp1);
2069     {
2070       if (sizeof(signed int) == 1) {
2071         arg2 = amglue_SvI8(ST(1));
2072       } else if (sizeof(signed int) == 2) {
2073         arg2 = amglue_SvI16(ST(1));
2074       } else if (sizeof(signed int) == 4) {
2075         arg2 = amglue_SvI32(ST(1));
2076       } else if (sizeof(signed int) == 8) {
2077         arg2 = amglue_SvI64(ST(1));
2078       } else {
2079         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2080       }
2081     }
2082     if (arg1) (arg1)->dumplevel = arg2;
2083     ST(argvi) = sv_newmortal();
2084
2085
2086     XSRETURN(argvi);
2087   fail:
2088
2089
2090     SWIG_croak_null();
2091   }
2092 }
2093
2094
2095 XS(_wrap_Header_dumplevel_get) {
2096   {
2097     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2098     void *argp1 = 0 ;
2099     int res1 = 0 ;
2100     int argvi = 0;
2101     int result;
2102     dXSARGS;
2103
2104     if ((items < 1) || (items > 1)) {
2105       SWIG_croak("Usage: Header_dumplevel_get(self);");
2106     }
2107     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2108     if (!SWIG_IsOK(res1)) {
2109       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dumplevel_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2110     }
2111     arg1 = (dumpfile_t *)(argp1);
2112     result = (int) ((arg1)->dumplevel);
2113     {
2114       SV *for_stack;
2115       SP += argvi; PUTBACK;
2116       for_stack = sv_2mortal(amglue_newSVi64(result));
2117       SPAGAIN; SP -= argvi;
2118       ST(argvi) = for_stack;
2119       argvi++;
2120     }
2121
2122     XSRETURN(argvi);
2123   fail:
2124
2125     SWIG_croak_null();
2126   }
2127 }
2128
2129
2130 XS(_wrap_Header_compressed_set) {
2131   {
2132     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2133     int arg2 ;
2134     void *argp1 = 0 ;
2135     int res1 = 0 ;
2136     int argvi = 0;
2137     dXSARGS;
2138
2139     if ((items < 2) || (items > 2)) {
2140       SWIG_croak("Usage: Header_compressed_set(self,compressed);");
2141     }
2142     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2143     if (!SWIG_IsOK(res1)) {
2144       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_compressed_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2145     }
2146     arg1 = (dumpfile_t *)(argp1);
2147     {
2148       if (sizeof(signed int) == 1) {
2149         arg2 = amglue_SvI8(ST(1));
2150       } else if (sizeof(signed int) == 2) {
2151         arg2 = amglue_SvI16(ST(1));
2152       } else if (sizeof(signed int) == 4) {
2153         arg2 = amglue_SvI32(ST(1));
2154       } else if (sizeof(signed int) == 8) {
2155         arg2 = amglue_SvI64(ST(1));
2156       } else {
2157         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2158       }
2159     }
2160     if (arg1) (arg1)->compressed = arg2;
2161     ST(argvi) = sv_newmortal();
2162
2163
2164     XSRETURN(argvi);
2165   fail:
2166
2167
2168     SWIG_croak_null();
2169   }
2170 }
2171
2172
2173 XS(_wrap_Header_compressed_get) {
2174   {
2175     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2176     void *argp1 = 0 ;
2177     int res1 = 0 ;
2178     int argvi = 0;
2179     int result;
2180     dXSARGS;
2181
2182     if ((items < 1) || (items > 1)) {
2183       SWIG_croak("Usage: Header_compressed_get(self);");
2184     }
2185     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2186     if (!SWIG_IsOK(res1)) {
2187       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_compressed_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2188     }
2189     arg1 = (dumpfile_t *)(argp1);
2190     result = (int) ((arg1)->compressed);
2191     {
2192       SV *for_stack;
2193       SP += argvi; PUTBACK;
2194       for_stack = sv_2mortal(amglue_newSVi64(result));
2195       SPAGAIN; SP -= argvi;
2196       ST(argvi) = for_stack;
2197       argvi++;
2198     }
2199
2200     XSRETURN(argvi);
2201   fail:
2202
2203     SWIG_croak_null();
2204   }
2205 }
2206
2207
2208 XS(_wrap_Header_encrypted_set) {
2209   {
2210     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2211     int arg2 ;
2212     void *argp1 = 0 ;
2213     int res1 = 0 ;
2214     int argvi = 0;
2215     dXSARGS;
2216
2217     if ((items < 2) || (items > 2)) {
2218       SWIG_croak("Usage: Header_encrypted_set(self,encrypted);");
2219     }
2220     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2221     if (!SWIG_IsOK(res1)) {
2222       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypted_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2223     }
2224     arg1 = (dumpfile_t *)(argp1);
2225     {
2226       if (sizeof(signed int) == 1) {
2227         arg2 = amglue_SvI8(ST(1));
2228       } else if (sizeof(signed int) == 2) {
2229         arg2 = amglue_SvI16(ST(1));
2230       } else if (sizeof(signed int) == 4) {
2231         arg2 = amglue_SvI32(ST(1));
2232       } else if (sizeof(signed int) == 8) {
2233         arg2 = amglue_SvI64(ST(1));
2234       } else {
2235         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2236       }
2237     }
2238     if (arg1) (arg1)->encrypted = arg2;
2239     ST(argvi) = sv_newmortal();
2240
2241
2242     XSRETURN(argvi);
2243   fail:
2244
2245
2246     SWIG_croak_null();
2247   }
2248 }
2249
2250
2251 XS(_wrap_Header_encrypted_get) {
2252   {
2253     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2254     void *argp1 = 0 ;
2255     int res1 = 0 ;
2256     int argvi = 0;
2257     int result;
2258     dXSARGS;
2259
2260     if ((items < 1) || (items > 1)) {
2261       SWIG_croak("Usage: Header_encrypted_get(self);");
2262     }
2263     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2264     if (!SWIG_IsOK(res1)) {
2265       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypted_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2266     }
2267     arg1 = (dumpfile_t *)(argp1);
2268     result = (int) ((arg1)->encrypted);
2269     {
2270       SV *for_stack;
2271       SP += argvi; PUTBACK;
2272       for_stack = sv_2mortal(amglue_newSVi64(result));
2273       SPAGAIN; SP -= argvi;
2274       ST(argvi) = for_stack;
2275       argvi++;
2276     }
2277
2278     XSRETURN(argvi);
2279   fail:
2280
2281     SWIG_croak_null();
2282   }
2283 }
2284
2285
2286 XS(_wrap_Header_comp_suffix_set) {
2287   {
2288     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2289     char *arg2 ;
2290     void *argp1 = 0 ;
2291     int res1 = 0 ;
2292     char temp2[STRMAX] ;
2293     int res2 ;
2294     int argvi = 0;
2295     dXSARGS;
2296
2297     if ((items < 2) || (items > 2)) {
2298       SWIG_croak("Usage: Header_comp_suffix_set(self,comp_suffix);");
2299     }
2300     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2301     if (!SWIG_IsOK(res1)) {
2302       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_comp_suffix_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2303     }
2304     arg1 = (dumpfile_t *)(argp1);
2305     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2306     if (!SWIG_IsOK(res2)) {
2307       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_comp_suffix_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2308     }
2309     arg2 = (char *)(temp2);
2310     {
2311       strncpy(arg1->comp_suffix, arg2, STRMAX);
2312       if (arg1->comp_suffix[STRMAX-1] != '\0')
2313       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2314     }
2315     ST(argvi) = sv_newmortal();
2316
2317
2318     XSRETURN(argvi);
2319   fail:
2320
2321
2322     SWIG_croak_null();
2323   }
2324 }
2325
2326
2327 XS(_wrap_Header_comp_suffix_get) {
2328   {
2329     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2330     void *argp1 = 0 ;
2331     int res1 = 0 ;
2332     int argvi = 0;
2333     char *result = 0 ;
2334     dXSARGS;
2335
2336     if ((items < 1) || (items > 1)) {
2337       SWIG_croak("Usage: Header_comp_suffix_get(self);");
2338     }
2339     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2340     if (!SWIG_IsOK(res1)) {
2341       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_comp_suffix_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2342     }
2343     arg1 = (dumpfile_t *)(argp1);
2344     result = (char *) ((arg1)->comp_suffix);
2345     {
2346       size_t size = STRMAX;
2347
2348       while (size && (result[size - 1] == '\0')) --size;
2349
2350       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2351     }
2352
2353     XSRETURN(argvi);
2354   fail:
2355
2356     SWIG_croak_null();
2357   }
2358 }
2359
2360
2361 XS(_wrap_Header_encrypt_suffix_set) {
2362   {
2363     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2364     char *arg2 ;
2365     void *argp1 = 0 ;
2366     int res1 = 0 ;
2367     char temp2[STRMAX] ;
2368     int res2 ;
2369     int argvi = 0;
2370     dXSARGS;
2371
2372     if ((items < 2) || (items > 2)) {
2373       SWIG_croak("Usage: Header_encrypt_suffix_set(self,encrypt_suffix);");
2374     }
2375     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2376     if (!SWIG_IsOK(res1)) {
2377       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypt_suffix_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2378     }
2379     arg1 = (dumpfile_t *)(argp1);
2380     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2381     if (!SWIG_IsOK(res2)) {
2382       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_encrypt_suffix_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2383     }
2384     arg2 = (char *)(temp2);
2385     {
2386       strncpy(arg1->encrypt_suffix, arg2, STRMAX);
2387       if (arg1->encrypt_suffix[STRMAX-1] != '\0')
2388       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2389     }
2390     ST(argvi) = sv_newmortal();
2391
2392
2393     XSRETURN(argvi);
2394   fail:
2395
2396
2397     SWIG_croak_null();
2398   }
2399 }
2400
2401
2402 XS(_wrap_Header_encrypt_suffix_get) {
2403   {
2404     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2405     void *argp1 = 0 ;
2406     int res1 = 0 ;
2407     int argvi = 0;
2408     char *result = 0 ;
2409     dXSARGS;
2410
2411     if ((items < 1) || (items > 1)) {
2412       SWIG_croak("Usage: Header_encrypt_suffix_get(self);");
2413     }
2414     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2415     if (!SWIG_IsOK(res1)) {
2416       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypt_suffix_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2417     }
2418     arg1 = (dumpfile_t *)(argp1);
2419     result = (char *) ((arg1)->encrypt_suffix);
2420     {
2421       size_t size = STRMAX;
2422
2423       while (size && (result[size - 1] == '\0')) --size;
2424
2425       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2426     }
2427
2428     XSRETURN(argvi);
2429   fail:
2430
2431     SWIG_croak_null();
2432   }
2433 }
2434
2435
2436 XS(_wrap_Header_name_set) {
2437   {
2438     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2439     char *arg2 ;
2440     void *argp1 = 0 ;
2441     int res1 = 0 ;
2442     char temp2[STRMAX] ;
2443     int res2 ;
2444     int argvi = 0;
2445     dXSARGS;
2446
2447     if ((items < 2) || (items > 2)) {
2448       SWIG_croak("Usage: Header_name_set(self,name);");
2449     }
2450     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2451     if (!SWIG_IsOK(res1)) {
2452       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_name_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2453     }
2454     arg1 = (dumpfile_t *)(argp1);
2455     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2456     if (!SWIG_IsOK(res2)) {
2457       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_name_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2458     }
2459     arg2 = (char *)(temp2);
2460     {
2461       strncpy(arg1->name, arg2, STRMAX);
2462       if (arg1->name[STRMAX-1] != '\0')
2463       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2464     }
2465     ST(argvi) = sv_newmortal();
2466
2467
2468     XSRETURN(argvi);
2469   fail:
2470
2471
2472     SWIG_croak_null();
2473   }
2474 }
2475
2476
2477 XS(_wrap_Header_name_get) {
2478   {
2479     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2480     void *argp1 = 0 ;
2481     int res1 = 0 ;
2482     int argvi = 0;
2483     char *result = 0 ;
2484     dXSARGS;
2485
2486     if ((items < 1) || (items > 1)) {
2487       SWIG_croak("Usage: Header_name_get(self);");
2488     }
2489     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2490     if (!SWIG_IsOK(res1)) {
2491       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_name_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2492     }
2493     arg1 = (dumpfile_t *)(argp1);
2494     result = (char *) ((arg1)->name);
2495     {
2496       size_t size = STRMAX;
2497
2498       while (size && (result[size - 1] == '\0')) --size;
2499
2500       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2501     }
2502
2503     XSRETURN(argvi);
2504   fail:
2505
2506     SWIG_croak_null();
2507   }
2508 }
2509
2510
2511 XS(_wrap_Header_disk_set) {
2512   {
2513     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2514     char *arg2 ;
2515     void *argp1 = 0 ;
2516     int res1 = 0 ;
2517     char temp2[STRMAX] ;
2518     int res2 ;
2519     int argvi = 0;
2520     dXSARGS;
2521
2522     if ((items < 2) || (items > 2)) {
2523       SWIG_croak("Usage: Header_disk_set(self,disk);");
2524     }
2525     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2526     if (!SWIG_IsOK(res1)) {
2527       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_disk_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2528     }
2529     arg1 = (dumpfile_t *)(argp1);
2530     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2531     if (!SWIG_IsOK(res2)) {
2532       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_disk_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2533     }
2534     arg2 = (char *)(temp2);
2535     {
2536       strncpy(arg1->disk, arg2, STRMAX);
2537       if (arg1->disk[STRMAX-1] != '\0')
2538       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2539     }
2540     ST(argvi) = sv_newmortal();
2541
2542
2543     XSRETURN(argvi);
2544   fail:
2545
2546
2547     SWIG_croak_null();
2548   }
2549 }
2550
2551
2552 XS(_wrap_Header_disk_get) {
2553   {
2554     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2555     void *argp1 = 0 ;
2556     int res1 = 0 ;
2557     int argvi = 0;
2558     char *result = 0 ;
2559     dXSARGS;
2560
2561     if ((items < 1) || (items > 1)) {
2562       SWIG_croak("Usage: Header_disk_get(self);");
2563     }
2564     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2565     if (!SWIG_IsOK(res1)) {
2566       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_disk_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2567     }
2568     arg1 = (dumpfile_t *)(argp1);
2569     result = (char *) ((arg1)->disk);
2570     {
2571       size_t size = STRMAX;
2572
2573       while (size && (result[size - 1] == '\0')) --size;
2574
2575       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2576     }
2577
2578     XSRETURN(argvi);
2579   fail:
2580
2581     SWIG_croak_null();
2582   }
2583 }
2584
2585
2586 XS(_wrap_Header_program_set) {
2587   {
2588     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2589     char *arg2 ;
2590     void *argp1 = 0 ;
2591     int res1 = 0 ;
2592     char temp2[STRMAX] ;
2593     int res2 ;
2594     int argvi = 0;
2595     dXSARGS;
2596
2597     if ((items < 2) || (items > 2)) {
2598       SWIG_croak("Usage: Header_program_set(self,program);");
2599     }
2600     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2601     if (!SWIG_IsOK(res1)) {
2602       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_program_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2603     }
2604     arg1 = (dumpfile_t *)(argp1);
2605     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2606     if (!SWIG_IsOK(res2)) {
2607       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_program_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2608     }
2609     arg2 = (char *)(temp2);
2610     {
2611       strncpy(arg1->program, arg2, STRMAX);
2612       if (arg1->program[STRMAX-1] != '\0')
2613       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2614     }
2615     ST(argvi) = sv_newmortal();
2616
2617
2618     XSRETURN(argvi);
2619   fail:
2620
2621
2622     SWIG_croak_null();
2623   }
2624 }
2625
2626
2627 XS(_wrap_Header_program_get) {
2628   {
2629     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2630     void *argp1 = 0 ;
2631     int res1 = 0 ;
2632     int argvi = 0;
2633     char *result = 0 ;
2634     dXSARGS;
2635
2636     if ((items < 1) || (items > 1)) {
2637       SWIG_croak("Usage: Header_program_get(self);");
2638     }
2639     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2640     if (!SWIG_IsOK(res1)) {
2641       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_program_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2642     }
2643     arg1 = (dumpfile_t *)(argp1);
2644     result = (char *) ((arg1)->program);
2645     {
2646       size_t size = STRMAX;
2647
2648       while (size && (result[size - 1] == '\0')) --size;
2649
2650       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2651     }
2652
2653     XSRETURN(argvi);
2654   fail:
2655
2656     SWIG_croak_null();
2657   }
2658 }
2659
2660
2661 XS(_wrap_Header_application_set) {
2662   {
2663     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2664     char *arg2 ;
2665     void *argp1 = 0 ;
2666     int res1 = 0 ;
2667     char temp2[STRMAX] ;
2668     int res2 ;
2669     int argvi = 0;
2670     dXSARGS;
2671
2672     if ((items < 2) || (items > 2)) {
2673       SWIG_croak("Usage: Header_application_set(self,application);");
2674     }
2675     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2676     if (!SWIG_IsOK(res1)) {
2677       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_application_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2678     }
2679     arg1 = (dumpfile_t *)(argp1);
2680     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2681     if (!SWIG_IsOK(res2)) {
2682       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_application_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2683     }
2684     arg2 = (char *)(temp2);
2685     {
2686       strncpy(arg1->application, arg2, STRMAX);
2687       if (arg1->application[STRMAX-1] != '\0')
2688       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2689     }
2690     ST(argvi) = sv_newmortal();
2691
2692
2693     XSRETURN(argvi);
2694   fail:
2695
2696
2697     SWIG_croak_null();
2698   }
2699 }
2700
2701
2702 XS(_wrap_Header_application_get) {
2703   {
2704     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2705     void *argp1 = 0 ;
2706     int res1 = 0 ;
2707     int argvi = 0;
2708     char *result = 0 ;
2709     dXSARGS;
2710
2711     if ((items < 1) || (items > 1)) {
2712       SWIG_croak("Usage: Header_application_get(self);");
2713     }
2714     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2715     if (!SWIG_IsOK(res1)) {
2716       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_application_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2717     }
2718     arg1 = (dumpfile_t *)(argp1);
2719     result = (char *) ((arg1)->application);
2720     {
2721       size_t size = STRMAX;
2722
2723       while (size && (result[size - 1] == '\0')) --size;
2724
2725       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2726     }
2727
2728     XSRETURN(argvi);
2729   fail:
2730
2731     SWIG_croak_null();
2732   }
2733 }
2734
2735
2736 XS(_wrap_Header_srvcompprog_set) {
2737   {
2738     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2739     char *arg2 ;
2740     void *argp1 = 0 ;
2741     int res1 = 0 ;
2742     char temp2[STRMAX] ;
2743     int res2 ;
2744     int argvi = 0;
2745     dXSARGS;
2746
2747     if ((items < 2) || (items > 2)) {
2748       SWIG_croak("Usage: Header_srvcompprog_set(self,srvcompprog);");
2749     }
2750     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2751     if (!SWIG_IsOK(res1)) {
2752       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srvcompprog_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2753     }
2754     arg1 = (dumpfile_t *)(argp1);
2755     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2756     if (!SWIG_IsOK(res2)) {
2757       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srvcompprog_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2758     }
2759     arg2 = (char *)(temp2);
2760     {
2761       strncpy(arg1->srvcompprog, arg2, STRMAX);
2762       if (arg1->srvcompprog[STRMAX-1] != '\0')
2763       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2764     }
2765     ST(argvi) = sv_newmortal();
2766
2767
2768     XSRETURN(argvi);
2769   fail:
2770
2771
2772     SWIG_croak_null();
2773   }
2774 }
2775
2776
2777 XS(_wrap_Header_srvcompprog_get) {
2778   {
2779     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2780     void *argp1 = 0 ;
2781     int res1 = 0 ;
2782     int argvi = 0;
2783     char *result = 0 ;
2784     dXSARGS;
2785
2786     if ((items < 1) || (items > 1)) {
2787       SWIG_croak("Usage: Header_srvcompprog_get(self);");
2788     }
2789     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2790     if (!SWIG_IsOK(res1)) {
2791       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srvcompprog_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2792     }
2793     arg1 = (dumpfile_t *)(argp1);
2794     result = (char *) ((arg1)->srvcompprog);
2795     {
2796       size_t size = STRMAX;
2797
2798       while (size && (result[size - 1] == '\0')) --size;
2799
2800       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2801     }
2802
2803     XSRETURN(argvi);
2804   fail:
2805
2806     SWIG_croak_null();
2807   }
2808 }
2809
2810
2811 XS(_wrap_Header_clntcompprog_set) {
2812   {
2813     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2814     char *arg2 ;
2815     void *argp1 = 0 ;
2816     int res1 = 0 ;
2817     char temp2[STRMAX] ;
2818     int res2 ;
2819     int argvi = 0;
2820     dXSARGS;
2821
2822     if ((items < 2) || (items > 2)) {
2823       SWIG_croak("Usage: Header_clntcompprog_set(self,clntcompprog);");
2824     }
2825     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2826     if (!SWIG_IsOK(res1)) {
2827       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clntcompprog_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2828     }
2829     arg1 = (dumpfile_t *)(argp1);
2830     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2831     if (!SWIG_IsOK(res2)) {
2832       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clntcompprog_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2833     }
2834     arg2 = (char *)(temp2);
2835     {
2836       strncpy(arg1->clntcompprog, arg2, STRMAX);
2837       if (arg1->clntcompprog[STRMAX-1] != '\0')
2838       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2839     }
2840     ST(argvi) = sv_newmortal();
2841
2842
2843     XSRETURN(argvi);
2844   fail:
2845
2846
2847     SWIG_croak_null();
2848   }
2849 }
2850
2851
2852 XS(_wrap_Header_clntcompprog_get) {
2853   {
2854     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2855     void *argp1 = 0 ;
2856     int res1 = 0 ;
2857     int argvi = 0;
2858     char *result = 0 ;
2859     dXSARGS;
2860
2861     if ((items < 1) || (items > 1)) {
2862       SWIG_croak("Usage: Header_clntcompprog_get(self);");
2863     }
2864     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2865     if (!SWIG_IsOK(res1)) {
2866       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clntcompprog_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2867     }
2868     arg1 = (dumpfile_t *)(argp1);
2869     result = (char *) ((arg1)->clntcompprog);
2870     {
2871       size_t size = STRMAX;
2872
2873       while (size && (result[size - 1] == '\0')) --size;
2874
2875       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2876     }
2877
2878     XSRETURN(argvi);
2879   fail:
2880
2881     SWIG_croak_null();
2882   }
2883 }
2884
2885
2886 XS(_wrap_Header_srv_encrypt_set) {
2887   {
2888     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2889     char *arg2 ;
2890     void *argp1 = 0 ;
2891     int res1 = 0 ;
2892     char temp2[STRMAX] ;
2893     int res2 ;
2894     int argvi = 0;
2895     dXSARGS;
2896
2897     if ((items < 2) || (items > 2)) {
2898       SWIG_croak("Usage: Header_srv_encrypt_set(self,srv_encrypt);");
2899     }
2900     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2901     if (!SWIG_IsOK(res1)) {
2902       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_encrypt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2903     }
2904     arg1 = (dumpfile_t *)(argp1);
2905     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2906     if (!SWIG_IsOK(res2)) {
2907       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srv_encrypt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2908     }
2909     arg2 = (char *)(temp2);
2910     {
2911       strncpy(arg1->srv_encrypt, arg2, STRMAX);
2912       if (arg1->srv_encrypt[STRMAX-1] != '\0')
2913       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2914     }
2915     ST(argvi) = sv_newmortal();
2916
2917
2918     XSRETURN(argvi);
2919   fail:
2920
2921
2922     SWIG_croak_null();
2923   }
2924 }
2925
2926
2927 XS(_wrap_Header_srv_encrypt_get) {
2928   {
2929     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2930     void *argp1 = 0 ;
2931     int res1 = 0 ;
2932     int argvi = 0;
2933     char *result = 0 ;
2934     dXSARGS;
2935
2936     if ((items < 1) || (items > 1)) {
2937       SWIG_croak("Usage: Header_srv_encrypt_get(self);");
2938     }
2939     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2940     if (!SWIG_IsOK(res1)) {
2941       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_encrypt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2942     }
2943     arg1 = (dumpfile_t *)(argp1);
2944     result = (char *) ((arg1)->srv_encrypt);
2945     {
2946       size_t size = STRMAX;
2947
2948       while (size && (result[size - 1] == '\0')) --size;
2949
2950       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2951     }
2952
2953     XSRETURN(argvi);
2954   fail:
2955
2956     SWIG_croak_null();
2957   }
2958 }
2959
2960
2961 XS(_wrap_Header_clnt_encrypt_set) {
2962   {
2963     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2964     char *arg2 ;
2965     void *argp1 = 0 ;
2966     int res1 = 0 ;
2967     char temp2[STRMAX] ;
2968     int res2 ;
2969     int argvi = 0;
2970     dXSARGS;
2971
2972     if ((items < 2) || (items > 2)) {
2973       SWIG_croak("Usage: Header_clnt_encrypt_set(self,clnt_encrypt);");
2974     }
2975     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2976     if (!SWIG_IsOK(res1)) {
2977       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_encrypt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2978     }
2979     arg1 = (dumpfile_t *)(argp1);
2980     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2981     if (!SWIG_IsOK(res2)) {
2982       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clnt_encrypt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2983     }
2984     arg2 = (char *)(temp2);
2985     {
2986       strncpy(arg1->clnt_encrypt, arg2, STRMAX);
2987       if (arg1->clnt_encrypt[STRMAX-1] != '\0')
2988       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2989     }
2990     ST(argvi) = sv_newmortal();
2991
2992
2993     XSRETURN(argvi);
2994   fail:
2995
2996
2997     SWIG_croak_null();
2998   }
2999 }
3000
3001
3002 XS(_wrap_Header_clnt_encrypt_get) {
3003   {
3004     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3005     void *argp1 = 0 ;
3006     int res1 = 0 ;
3007     int argvi = 0;
3008     char *result = 0 ;
3009     dXSARGS;
3010
3011     if ((items < 1) || (items > 1)) {
3012       SWIG_croak("Usage: Header_clnt_encrypt_get(self);");
3013     }
3014     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3015     if (!SWIG_IsOK(res1)) {
3016       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_encrypt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3017     }
3018     arg1 = (dumpfile_t *)(argp1);
3019     result = (char *) ((arg1)->clnt_encrypt);
3020     {
3021       size_t size = STRMAX;
3022
3023       while (size && (result[size - 1] == '\0')) --size;
3024
3025       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3026     }
3027
3028     XSRETURN(argvi);
3029   fail:
3030
3031     SWIG_croak_null();
3032   }
3033 }
3034
3035
3036 XS(_wrap_Header_recover_cmd_set) {
3037   {
3038     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3039     char *arg2 ;
3040     void *argp1 = 0 ;
3041     int res1 = 0 ;
3042     char temp2[STRMAX] ;
3043     int res2 ;
3044     int argvi = 0;
3045     dXSARGS;
3046
3047     if ((items < 2) || (items > 2)) {
3048       SWIG_croak("Usage: Header_recover_cmd_set(self,recover_cmd);");
3049     }
3050     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3051     if (!SWIG_IsOK(res1)) {
3052       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_recover_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3053     }
3054     arg1 = (dumpfile_t *)(argp1);
3055     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3056     if (!SWIG_IsOK(res2)) {
3057       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_recover_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3058     }
3059     arg2 = (char *)(temp2);
3060     {
3061       strncpy(arg1->recover_cmd, arg2, STRMAX);
3062       if (arg1->recover_cmd[STRMAX-1] != '\0')
3063       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3064     }
3065     ST(argvi) = sv_newmortal();
3066
3067
3068     XSRETURN(argvi);
3069   fail:
3070
3071
3072     SWIG_croak_null();
3073   }
3074 }
3075
3076
3077 XS(_wrap_Header_recover_cmd_get) {
3078   {
3079     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3080     void *argp1 = 0 ;
3081     int res1 = 0 ;
3082     int argvi = 0;
3083     char *result = 0 ;
3084     dXSARGS;
3085
3086     if ((items < 1) || (items > 1)) {
3087       SWIG_croak("Usage: Header_recover_cmd_get(self);");
3088     }
3089     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3090     if (!SWIG_IsOK(res1)) {
3091       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_recover_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3092     }
3093     arg1 = (dumpfile_t *)(argp1);
3094     result = (char *) ((arg1)->recover_cmd);
3095     {
3096       size_t size = STRMAX;
3097
3098       while (size && (result[size - 1] == '\0')) --size;
3099
3100       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3101     }
3102
3103     XSRETURN(argvi);
3104   fail:
3105
3106     SWIG_croak_null();
3107   }
3108 }
3109
3110
3111 XS(_wrap_Header_uncompress_cmd_set) {
3112   {
3113     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3114     char *arg2 ;
3115     void *argp1 = 0 ;
3116     int res1 = 0 ;
3117     char temp2[STRMAX] ;
3118     int res2 ;
3119     int argvi = 0;
3120     dXSARGS;
3121
3122     if ((items < 2) || (items > 2)) {
3123       SWIG_croak("Usage: Header_uncompress_cmd_set(self,uncompress_cmd);");
3124     }
3125     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3126     if (!SWIG_IsOK(res1)) {
3127       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_uncompress_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3128     }
3129     arg1 = (dumpfile_t *)(argp1);
3130     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3131     if (!SWIG_IsOK(res2)) {
3132       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_uncompress_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3133     }
3134     arg2 = (char *)(temp2);
3135     {
3136       strncpy(arg1->uncompress_cmd, arg2, STRMAX);
3137       if (arg1->uncompress_cmd[STRMAX-1] != '\0')
3138       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3139     }
3140     ST(argvi) = sv_newmortal();
3141
3142
3143     XSRETURN(argvi);
3144   fail:
3145
3146
3147     SWIG_croak_null();
3148   }
3149 }
3150
3151
3152 XS(_wrap_Header_uncompress_cmd_get) {
3153   {
3154     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3155     void *argp1 = 0 ;
3156     int res1 = 0 ;
3157     int argvi = 0;
3158     char *result = 0 ;
3159     dXSARGS;
3160
3161     if ((items < 1) || (items > 1)) {
3162       SWIG_croak("Usage: Header_uncompress_cmd_get(self);");
3163     }
3164     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3165     if (!SWIG_IsOK(res1)) {
3166       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_uncompress_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3167     }
3168     arg1 = (dumpfile_t *)(argp1);
3169     result = (char *) ((arg1)->uncompress_cmd);
3170     {
3171       size_t size = STRMAX;
3172
3173       while (size && (result[size - 1] == '\0')) --size;
3174
3175       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3176     }
3177
3178     XSRETURN(argvi);
3179   fail:
3180
3181     SWIG_croak_null();
3182   }
3183 }
3184
3185
3186 XS(_wrap_Header_decrypt_cmd_set) {
3187   {
3188     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3189     char *arg2 ;
3190     void *argp1 = 0 ;
3191     int res1 = 0 ;
3192     char temp2[STRMAX] ;
3193     int res2 ;
3194     int argvi = 0;
3195     dXSARGS;
3196
3197     if ((items < 2) || (items > 2)) {
3198       SWIG_croak("Usage: Header_decrypt_cmd_set(self,decrypt_cmd);");
3199     }
3200     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3201     if (!SWIG_IsOK(res1)) {
3202       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_decrypt_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3203     }
3204     arg1 = (dumpfile_t *)(argp1);
3205     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3206     if (!SWIG_IsOK(res2)) {
3207       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_decrypt_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3208     }
3209     arg2 = (char *)(temp2);
3210     {
3211       strncpy(arg1->decrypt_cmd, arg2, STRMAX);
3212       if (arg1->decrypt_cmd[STRMAX-1] != '\0')
3213       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3214     }
3215     ST(argvi) = sv_newmortal();
3216
3217
3218     XSRETURN(argvi);
3219   fail:
3220
3221
3222     SWIG_croak_null();
3223   }
3224 }
3225
3226
3227 XS(_wrap_Header_decrypt_cmd_get) {
3228   {
3229     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3230     void *argp1 = 0 ;
3231     int res1 = 0 ;
3232     int argvi = 0;
3233     char *result = 0 ;
3234     dXSARGS;
3235
3236     if ((items < 1) || (items > 1)) {
3237       SWIG_croak("Usage: Header_decrypt_cmd_get(self);");
3238     }
3239     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3240     if (!SWIG_IsOK(res1)) {
3241       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_decrypt_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3242     }
3243     arg1 = (dumpfile_t *)(argp1);
3244     result = (char *) ((arg1)->decrypt_cmd);
3245     {
3246       size_t size = STRMAX;
3247
3248       while (size && (result[size - 1] == '\0')) --size;
3249
3250       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3251     }
3252
3253     XSRETURN(argvi);
3254   fail:
3255
3256     SWIG_croak_null();
3257   }
3258 }
3259
3260
3261 XS(_wrap_Header_srv_decrypt_opt_set) {
3262   {
3263     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3264     char *arg2 ;
3265     void *argp1 = 0 ;
3266     int res1 = 0 ;
3267     char temp2[STRMAX] ;
3268     int res2 ;
3269     int argvi = 0;
3270     dXSARGS;
3271
3272     if ((items < 2) || (items > 2)) {
3273       SWIG_croak("Usage: Header_srv_decrypt_opt_set(self,srv_decrypt_opt);");
3274     }
3275     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3276     if (!SWIG_IsOK(res1)) {
3277       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_decrypt_opt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3278     }
3279     arg1 = (dumpfile_t *)(argp1);
3280     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3281     if (!SWIG_IsOK(res2)) {
3282       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srv_decrypt_opt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3283     }
3284     arg2 = (char *)(temp2);
3285     {
3286       strncpy(arg1->srv_decrypt_opt, arg2, STRMAX);
3287       if (arg1->srv_decrypt_opt[STRMAX-1] != '\0')
3288       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3289     }
3290     ST(argvi) = sv_newmortal();
3291
3292
3293     XSRETURN(argvi);
3294   fail:
3295
3296
3297     SWIG_croak_null();
3298   }
3299 }
3300
3301
3302 XS(_wrap_Header_srv_decrypt_opt_get) {
3303   {
3304     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3305     void *argp1 = 0 ;
3306     int res1 = 0 ;
3307     int argvi = 0;
3308     char *result = 0 ;
3309     dXSARGS;
3310
3311     if ((items < 1) || (items > 1)) {
3312       SWIG_croak("Usage: Header_srv_decrypt_opt_get(self);");
3313     }
3314     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3315     if (!SWIG_IsOK(res1)) {
3316       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_decrypt_opt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3317     }
3318     arg1 = (dumpfile_t *)(argp1);
3319     result = (char *) ((arg1)->srv_decrypt_opt);
3320     {
3321       size_t size = STRMAX;
3322
3323       while (size && (result[size - 1] == '\0')) --size;
3324
3325       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3326     }
3327
3328     XSRETURN(argvi);
3329   fail:
3330
3331     SWIG_croak_null();
3332   }
3333 }
3334
3335
3336 XS(_wrap_Header_clnt_decrypt_opt_set) {
3337   {
3338     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3339     char *arg2 ;
3340     void *argp1 = 0 ;
3341     int res1 = 0 ;
3342     char temp2[STRMAX] ;
3343     int res2 ;
3344     int argvi = 0;
3345     dXSARGS;
3346
3347     if ((items < 2) || (items > 2)) {
3348       SWIG_croak("Usage: Header_clnt_decrypt_opt_set(self,clnt_decrypt_opt);");
3349     }
3350     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3351     if (!SWIG_IsOK(res1)) {
3352       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_decrypt_opt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3353     }
3354     arg1 = (dumpfile_t *)(argp1);
3355     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3356     if (!SWIG_IsOK(res2)) {
3357       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clnt_decrypt_opt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3358     }
3359     arg2 = (char *)(temp2);
3360     {
3361       strncpy(arg1->clnt_decrypt_opt, arg2, STRMAX);
3362       if (arg1->clnt_decrypt_opt[STRMAX-1] != '\0')
3363       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3364     }
3365     ST(argvi) = sv_newmortal();
3366
3367
3368     XSRETURN(argvi);
3369   fail:
3370
3371
3372     SWIG_croak_null();
3373   }
3374 }
3375
3376
3377 XS(_wrap_Header_clnt_decrypt_opt_get) {
3378   {
3379     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3380     void *argp1 = 0 ;
3381     int res1 = 0 ;
3382     int argvi = 0;
3383     char *result = 0 ;
3384     dXSARGS;
3385
3386     if ((items < 1) || (items > 1)) {
3387       SWIG_croak("Usage: Header_clnt_decrypt_opt_get(self);");
3388     }
3389     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3390     if (!SWIG_IsOK(res1)) {
3391       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_decrypt_opt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3392     }
3393     arg1 = (dumpfile_t *)(argp1);
3394     result = (char *) ((arg1)->clnt_decrypt_opt);
3395     {
3396       size_t size = STRMAX;
3397
3398       while (size && (result[size - 1] == '\0')) --size;
3399
3400       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3401     }
3402
3403     XSRETURN(argvi);
3404   fail:
3405
3406     SWIG_croak_null();
3407   }
3408 }
3409
3410
3411 XS(_wrap_Header_cont_filename_set) {
3412   {
3413     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3414     char *arg2 ;
3415     void *argp1 = 0 ;
3416     int res1 = 0 ;
3417     char temp2[STRMAX] ;
3418     int res2 ;
3419     int argvi = 0;
3420     dXSARGS;
3421
3422     if ((items < 2) || (items > 2)) {
3423       SWIG_croak("Usage: Header_cont_filename_set(self,cont_filename);");
3424     }
3425     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3426     if (!SWIG_IsOK(res1)) {
3427       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_cont_filename_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3428     }
3429     arg1 = (dumpfile_t *)(argp1);
3430     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3431     if (!SWIG_IsOK(res2)) {
3432       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_cont_filename_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3433     }
3434     arg2 = (char *)(temp2);
3435     {
3436       strncpy(arg1->cont_filename, arg2, STRMAX);
3437       if (arg1->cont_filename[STRMAX-1] != '\0')
3438       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3439     }
3440     ST(argvi) = sv_newmortal();
3441
3442
3443     XSRETURN(argvi);
3444   fail:
3445
3446
3447     SWIG_croak_null();
3448   }
3449 }
3450
3451
3452 XS(_wrap_Header_cont_filename_get) {
3453   {
3454     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3455     void *argp1 = 0 ;
3456     int res1 = 0 ;
3457     int argvi = 0;
3458     char *result = 0 ;
3459     dXSARGS;
3460
3461     if ((items < 1) || (items > 1)) {
3462       SWIG_croak("Usage: Header_cont_filename_get(self);");
3463     }
3464     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3465     if (!SWIG_IsOK(res1)) {
3466       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_cont_filename_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3467     }
3468     arg1 = (dumpfile_t *)(argp1);
3469     result = (char *) ((arg1)->cont_filename);
3470     {
3471       size_t size = STRMAX;
3472
3473       while (size && (result[size - 1] == '\0')) --size;
3474
3475       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3476     }
3477
3478     XSRETURN(argvi);
3479   fail:
3480
3481     SWIG_croak_null();
3482   }
3483 }
3484
3485
3486 XS(_wrap_Header_dle_str_set) {
3487   {
3488     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3489     char *arg2 = (char *) 0 ;
3490     void *argp1 = 0 ;
3491     int res1 = 0 ;
3492     int res2 ;
3493     char *buf2 = 0 ;
3494     int alloc2 = 0 ;
3495     int argvi = 0;
3496     dXSARGS;
3497
3498     if ((items < 2) || (items > 2)) {
3499       SWIG_croak("Usage: Header_dle_str_set(self,dle_str);");
3500     }
3501     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3502     if (!SWIG_IsOK(res1)) {
3503       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dle_str_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3504     }
3505     arg1 = (dumpfile_t *)(argp1);
3506     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3507     if (!SWIG_IsOK(res2)) {
3508       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_dle_str_set" "', argument " "2"" of type '" "char *""'");
3509     }
3510     arg2 = (char *)(buf2);
3511     if (arg1->dle_str) free((char*)arg1->dle_str);
3512     if (arg2) {
3513       size_t size = strlen((const char *)(arg2)) + 1;
3514       arg1->dle_str = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
3515     } else {
3516       arg1->dle_str = 0;
3517     }
3518     ST(argvi) = sv_newmortal();
3519
3520     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3521     XSRETURN(argvi);
3522   fail:
3523
3524     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3525     SWIG_croak_null();
3526   }
3527 }
3528
3529
3530 XS(_wrap_Header_dle_str_get) {
3531   {
3532     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3533     void *argp1 = 0 ;
3534     int res1 = 0 ;
3535     int argvi = 0;
3536     char *result = 0 ;
3537     dXSARGS;
3538
3539     if ((items < 1) || (items > 1)) {
3540       SWIG_croak("Usage: Header_dle_str_get(self);");
3541     }
3542     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3543     if (!SWIG_IsOK(res1)) {
3544       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dle_str_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3545     }
3546     arg1 = (dumpfile_t *)(argp1);
3547     result = (char *) ((arg1)->dle_str);
3548     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3549
3550     XSRETURN(argvi);
3551   fail:
3552
3553     SWIG_croak_null();
3554   }
3555 }
3556
3557
3558 XS(_wrap_Header_is_partial_set) {
3559   {
3560     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3561     int arg2 ;
3562     void *argp1 = 0 ;
3563     int res1 = 0 ;
3564     int argvi = 0;
3565     dXSARGS;
3566
3567     if ((items < 2) || (items > 2)) {
3568       SWIG_croak("Usage: Header_is_partial_set(self,is_partial);");
3569     }
3570     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3571     if (!SWIG_IsOK(res1)) {
3572       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_is_partial_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3573     }
3574     arg1 = (dumpfile_t *)(argp1);
3575     {
3576       if (sizeof(signed int) == 1) {
3577         arg2 = amglue_SvI8(ST(1));
3578       } else if (sizeof(signed int) == 2) {
3579         arg2 = amglue_SvI16(ST(1));
3580       } else if (sizeof(signed int) == 4) {
3581         arg2 = amglue_SvI32(ST(1));
3582       } else if (sizeof(signed int) == 8) {
3583         arg2 = amglue_SvI64(ST(1));
3584       } else {
3585         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3586       }
3587     }
3588     if (arg1) (arg1)->is_partial = arg2;
3589     ST(argvi) = sv_newmortal();
3590
3591
3592     XSRETURN(argvi);
3593   fail:
3594
3595
3596     SWIG_croak_null();
3597   }
3598 }
3599
3600
3601 XS(_wrap_Header_is_partial_get) {
3602   {
3603     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3604     void *argp1 = 0 ;
3605     int res1 = 0 ;
3606     int argvi = 0;
3607     int result;
3608     dXSARGS;
3609
3610     if ((items < 1) || (items > 1)) {
3611       SWIG_croak("Usage: Header_is_partial_get(self);");
3612     }
3613     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3614     if (!SWIG_IsOK(res1)) {
3615       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_is_partial_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3616     }
3617     arg1 = (dumpfile_t *)(argp1);
3618     result = (int) ((arg1)->is_partial);
3619     {
3620       SV *for_stack;
3621       SP += argvi; PUTBACK;
3622       for_stack = sv_2mortal(amglue_newSVi64(result));
3623       SPAGAIN; SP -= argvi;
3624       ST(argvi) = for_stack;
3625       argvi++;
3626     }
3627
3628     XSRETURN(argvi);
3629   fail:
3630
3631     SWIG_croak_null();
3632   }
3633 }
3634
3635
3636 XS(_wrap_Header_partnum_set) {
3637   {
3638     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3639     int arg2 ;
3640     void *argp1 = 0 ;
3641     int res1 = 0 ;
3642     int argvi = 0;
3643     dXSARGS;
3644
3645     if ((items < 2) || (items > 2)) {
3646       SWIG_croak("Usage: Header_partnum_set(self,partnum);");
3647     }
3648     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3649     if (!SWIG_IsOK(res1)) {
3650       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_partnum_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3651     }
3652     arg1 = (dumpfile_t *)(argp1);
3653     {
3654       if (sizeof(signed int) == 1) {
3655         arg2 = amglue_SvI8(ST(1));
3656       } else if (sizeof(signed int) == 2) {
3657         arg2 = amglue_SvI16(ST(1));
3658       } else if (sizeof(signed int) == 4) {
3659         arg2 = amglue_SvI32(ST(1));
3660       } else if (sizeof(signed int) == 8) {
3661         arg2 = amglue_SvI64(ST(1));
3662       } else {
3663         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3664       }
3665     }
3666     if (arg1) (arg1)->partnum = arg2;
3667     ST(argvi) = sv_newmortal();
3668
3669
3670     XSRETURN(argvi);
3671   fail:
3672
3673
3674     SWIG_croak_null();
3675   }
3676 }
3677
3678
3679 XS(_wrap_Header_partnum_get) {
3680   {
3681     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3682     void *argp1 = 0 ;
3683     int res1 = 0 ;
3684     int argvi = 0;
3685     int result;
3686     dXSARGS;
3687
3688     if ((items < 1) || (items > 1)) {
3689       SWIG_croak("Usage: Header_partnum_get(self);");
3690     }
3691     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3692     if (!SWIG_IsOK(res1)) {
3693       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_partnum_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3694     }
3695     arg1 = (dumpfile_t *)(argp1);
3696     result = (int) ((arg1)->partnum);
3697     {
3698       SV *for_stack;
3699       SP += argvi; PUTBACK;
3700       for_stack = sv_2mortal(amglue_newSVi64(result));
3701       SPAGAIN; SP -= argvi;
3702       ST(argvi) = for_stack;
3703       argvi++;
3704     }
3705
3706     XSRETURN(argvi);
3707   fail:
3708
3709     SWIG_croak_null();
3710   }
3711 }
3712
3713
3714 XS(_wrap_Header_totalparts_set) {
3715   {
3716     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3717     int arg2 ;
3718     void *argp1 = 0 ;
3719     int res1 = 0 ;
3720     int argvi = 0;
3721     dXSARGS;
3722
3723     if ((items < 2) || (items > 2)) {
3724       SWIG_croak("Usage: Header_totalparts_set(self,totalparts);");
3725     }
3726     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3727     if (!SWIG_IsOK(res1)) {
3728       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_totalparts_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3729     }
3730     arg1 = (dumpfile_t *)(argp1);
3731     {
3732       if (sizeof(signed int) == 1) {
3733         arg2 = amglue_SvI8(ST(1));
3734       } else if (sizeof(signed int) == 2) {
3735         arg2 = amglue_SvI16(ST(1));
3736       } else if (sizeof(signed int) == 4) {
3737         arg2 = amglue_SvI32(ST(1));
3738       } else if (sizeof(signed int) == 8) {
3739         arg2 = amglue_SvI64(ST(1));
3740       } else {
3741         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3742       }
3743     }
3744     if (arg1) (arg1)->totalparts = arg2;
3745     ST(argvi) = sv_newmortal();
3746
3747
3748     XSRETURN(argvi);
3749   fail:
3750
3751
3752     SWIG_croak_null();
3753   }
3754 }
3755
3756
3757 XS(_wrap_Header_totalparts_get) {
3758   {
3759     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3760     void *argp1 = 0 ;
3761     int res1 = 0 ;
3762     int argvi = 0;
3763     int result;
3764     dXSARGS;
3765
3766     if ((items < 1) || (items > 1)) {
3767       SWIG_croak("Usage: Header_totalparts_get(self);");
3768     }
3769     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3770     if (!SWIG_IsOK(res1)) {
3771       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_totalparts_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3772     }
3773     arg1 = (dumpfile_t *)(argp1);
3774     result = (int) ((arg1)->totalparts);
3775     {
3776       SV *for_stack;
3777       SP += argvi; PUTBACK;
3778       for_stack = sv_2mortal(amglue_newSVi64(result));
3779       SPAGAIN; SP -= argvi;
3780       ST(argvi) = for_stack;
3781       argvi++;
3782     }
3783
3784     XSRETURN(argvi);
3785   fail:
3786
3787     SWIG_croak_null();
3788   }
3789 }
3790
3791
3792 XS(_wrap_Header_blocksize_set) {
3793   {
3794     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3795     size_t arg2 ;
3796     void *argp1 = 0 ;
3797     int res1 = 0 ;
3798     int argvi = 0;
3799     dXSARGS;
3800
3801     if ((items < 2) || (items > 2)) {
3802       SWIG_croak("Usage: Header_blocksize_set(self,blocksize);");
3803     }
3804     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3805     if (!SWIG_IsOK(res1)) {
3806       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_blocksize_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3807     }
3808     arg1 = (dumpfile_t *)(argp1);
3809     {
3810       if (sizeof(size_t) == 1) {
3811         arg2 = amglue_SvU8(ST(1));
3812       } else if (sizeof(size_t) == 2) {
3813         arg2 = amglue_SvU16(ST(1));
3814       } else if (sizeof(size_t) == 4) {
3815         arg2 = amglue_SvU32(ST(1));
3816       } else if (sizeof(size_t) == 8) {
3817         arg2 = amglue_SvU64(ST(1));
3818       } else {
3819         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
3820       }
3821     }
3822     if (arg1) (arg1)->blocksize = arg2;
3823     ST(argvi) = sv_newmortal();
3824
3825
3826     XSRETURN(argvi);
3827   fail:
3828
3829
3830     SWIG_croak_null();
3831   }
3832 }
3833
3834
3835 XS(_wrap_Header_blocksize_get) {
3836   {
3837     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3838     void *argp1 = 0 ;
3839     int res1 = 0 ;
3840     int argvi = 0;
3841     size_t result;
3842     dXSARGS;
3843
3844     if ((items < 1) || (items > 1)) {
3845       SWIG_croak("Usage: Header_blocksize_get(self);");
3846     }
3847     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3848     if (!SWIG_IsOK(res1)) {
3849       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_blocksize_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3850     }
3851     arg1 = (dumpfile_t *)(argp1);
3852     result =  ((arg1)->blocksize);
3853     {
3854       SV *for_stack;
3855       SP += argvi; PUTBACK;
3856       for_stack = sv_2mortal(amglue_newSVu64(result));
3857       SPAGAIN; SP -= argvi;
3858       ST(argvi) = for_stack;
3859       argvi++;
3860     }
3861
3862     XSRETURN(argvi);
3863   fail:
3864
3865     SWIG_croak_null();
3866   }
3867 }
3868
3869
3870 XS(_wrap_Header_orig_size_set) {
3871   {
3872     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3873     off_t arg2 ;
3874     void *argp1 = 0 ;
3875     int res1 = 0 ;
3876     int argvi = 0;
3877     dXSARGS;
3878
3879     if ((items < 2) || (items > 2)) {
3880       SWIG_croak("Usage: Header_orig_size_set(self,orig_size);");
3881     }
3882     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3883     if (!SWIG_IsOK(res1)) {
3884       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_orig_size_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3885     }
3886     arg1 = (dumpfile_t *)(argp1);
3887     {
3888       if (sizeof(off_t) == 1) {
3889         arg2 = amglue_SvU8(ST(1));
3890       } else if (sizeof(off_t) == 2) {
3891         arg2 = amglue_SvU16(ST(1));
3892       } else if (sizeof(off_t) == 4) {
3893         arg2 = amglue_SvU32(ST(1));
3894       } else if (sizeof(off_t) == 8) {
3895         arg2 = amglue_SvU64(ST(1));
3896       } else {
3897         croak("Unexpected off_t >64 bits?"); /* should be optimized out unless sizeof(off_t) > 8 */
3898       }
3899     }
3900     if (arg1) (arg1)->orig_size = arg2;
3901     ST(argvi) = sv_newmortal();
3902
3903     XSRETURN(argvi);
3904   fail:
3905
3906     SWIG_croak_null();
3907   }
3908 }
3909
3910
3911 XS(_wrap_Header_orig_size_get) {
3912   {
3913     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3914     void *argp1 = 0 ;
3915     int res1 = 0 ;
3916     int argvi = 0;
3917     off_t result;
3918     dXSARGS;
3919
3920     if ((items < 1) || (items > 1)) {
3921       SWIG_croak("Usage: Header_orig_size_get(self);");
3922     }
3923     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3924     if (!SWIG_IsOK(res1)) {
3925       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_orig_size_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3926     }
3927     arg1 = (dumpfile_t *)(argp1);
3928     result =  ((arg1)->orig_size);
3929     {
3930       SV *for_stack;
3931       SP += argvi; PUTBACK;
3932       for_stack = sv_2mortal(amglue_newSVu64(result));
3933       SPAGAIN; SP -= argvi;
3934       ST(argvi) = for_stack;
3935       argvi++;
3936     }
3937
3938     XSRETURN(argvi);
3939   fail:
3940
3941     SWIG_croak_null();
3942   }
3943 }
3944
3945
3946 XS(_wrap_new_Header) {
3947   {
3948     int argvi = 0;
3949     dumpfile_t *result = 0 ;
3950     dXSARGS;
3951
3952     if ((items < 0) || (items > 0)) {
3953       SWIG_croak("Usage: new_Header();");
3954     }
3955     result = (dumpfile_t *)new_dumpfile_t();
3956     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3957     XSRETURN(argvi);
3958   fail:
3959     SWIG_croak_null();
3960   }
3961 }
3962
3963
3964 XS(_wrap_Header_to_string) {
3965   {
3966     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3967     size_t arg2 ;
3968     size_t arg3 ;
3969     void *argp1 = 0 ;
3970     int res1 = 0 ;
3971     int argvi = 0;
3972     SV *result = 0 ;
3973     dXSARGS;
3974
3975     if ((items < 3) || (items > 3)) {
3976       SWIG_croak("Usage: Header_to_string(self,min_size,max_size);");
3977     }
3978     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3979     if (!SWIG_IsOK(res1)) {
3980       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_to_string" "', argument " "1"" of type '" "dumpfile_t *""'");
3981     }
3982     arg1 = (dumpfile_t *)(argp1);
3983     {
3984       if (sizeof(size_t) == 1) {
3985         arg2 = amglue_SvU8(ST(1));
3986       } else if (sizeof(size_t) == 2) {
3987         arg2 = amglue_SvU16(ST(1));
3988       } else if (sizeof(size_t) == 4) {
3989         arg2 = amglue_SvU32(ST(1));
3990       } else if (sizeof(size_t) == 8) {
3991         arg2 = amglue_SvU64(ST(1));
3992       } else {
3993         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
3994       }
3995     }
3996     {
3997       if (sizeof(size_t) == 1) {
3998         arg3 = amglue_SvU8(ST(2));
3999       } else if (sizeof(size_t) == 2) {
4000         arg3 = amglue_SvU16(ST(2));
4001       } else if (sizeof(size_t) == 4) {
4002         arg3 = amglue_SvU32(ST(2));
4003       } else if (sizeof(size_t) == 8) {
4004         arg3 = amglue_SvU64(ST(2));
4005       } else {
4006         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
4007       }
4008     }
4009     result = (SV *)dumpfile_t_to_string(arg1,arg2,arg3);
4010     ST(argvi) = result; argvi++;
4011
4012
4013
4014     XSRETURN(argvi);
4015   fail:
4016
4017
4018
4019     SWIG_croak_null();
4020   }
4021 }
4022
4023
4024 XS(_wrap_Header_debug_dump) {
4025   {
4026     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4027     void *argp1 = 0 ;
4028     int res1 = 0 ;
4029     int argvi = 0;
4030     dXSARGS;
4031
4032     if ((items < 1) || (items > 1)) {
4033       SWIG_croak("Usage: Header_debug_dump(self);");
4034     }
4035     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
4036     if (!SWIG_IsOK(res1)) {
4037       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_debug_dump" "', argument " "1"" of type '" "dumpfile_t *""'");
4038     }
4039     arg1 = (dumpfile_t *)(argp1);
4040     dumpfile_t_debug_dump(arg1);
4041     ST(argvi) = sv_newmortal();
4042
4043     XSRETURN(argvi);
4044   fail:
4045
4046     SWIG_croak_null();
4047   }
4048 }
4049
4050
4051 XS(_wrap_Header_summary) {
4052   {
4053     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4054     void *argp1 = 0 ;
4055     int res1 = 0 ;
4056     int argvi = 0;
4057     char *result = 0 ;
4058     dXSARGS;
4059
4060     if ((items < 1) || (items > 1)) {
4061       SWIG_croak("Usage: Header_summary(self);");
4062     }
4063     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
4064     if (!SWIG_IsOK(res1)) {
4065       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_summary" "', argument " "1"" of type '" "dumpfile_t *""'");
4066     }
4067     arg1 = (dumpfile_t *)(argp1);
4068     result = (char *)dumpfile_t_summary(arg1);
4069     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4070
4071     free((char*)result);
4072     XSRETURN(argvi);
4073   fail:
4074
4075     SWIG_croak_null();
4076   }
4077 }
4078
4079
4080 XS(_wrap_delete_Header__SWIG_1) {
4081   {
4082     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4083     void *argp1 = 0 ;
4084     int res1 = 0 ;
4085     int argvi = 0;
4086     dXSARGS;
4087
4088     if ((items < 1) || (items > 1)) {
4089       SWIG_croak("Usage: delete_Header(self);");
4090     }
4091     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, SWIG_POINTER_DISOWN |  0 );
4092     if (!SWIG_IsOK(res1)) {
4093       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Header" "', argument " "1"" of type '" "dumpfile_t *""'");
4094     }
4095     arg1 = (dumpfile_t *)(argp1);
4096     free((char *) arg1);
4097     ST(argvi) = sv_newmortal();
4098
4099     XSRETURN(argvi);
4100   fail:
4101
4102     SWIG_croak_null();
4103   }
4104 }
4105
4106
4107 XS(_wrap_delete_Header) {
4108   dXSARGS;
4109
4110   {
4111     unsigned long _index = 0;
4112     SWIG_TypeRank _rank = 0;
4113     if (items == 1) {
4114       SWIG_TypeRank _ranki = 0;
4115       SWIG_TypeRank _rankm = 0;
4116       SWIG_TypeRank _pi = 1;
4117       int _v = 0;
4118       {
4119         void *vptr = 0;
4120         int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_dumpfile_t, 0);
4121         _v = SWIG_CheckState(res);
4122       }
4123       if (!_v) goto check_1;
4124       _ranki += _v*_pi;
4125       _rankm += _pi;
4126       _pi *= SWIG_MAXCASTRANK;
4127       if (!_index || (_ranki < _rank)) {
4128         _rank = _ranki; _index = 1;
4129         if (_rank == _rankm) goto dispatch;
4130       }
4131     }
4132   check_1:
4133
4134   dispatch:
4135     switch(_index) {
4136     case 1:
4137       ++PL_markstack_ptr; SWIG_CALLXS(_wrap_delete_Header__SWIG_1); return;
4138     }
4139   }
4140
4141   croak("No matching function for overloaded 'delete_Header'");
4142   XSRETURN(0);
4143 }
4144
4145
4146 XS(_wrap_C_from_string) {
4147   {
4148     char *arg1 = (char *) 0 ;
4149     int res1 ;
4150     char *buf1 = 0 ;
4151     int alloc1 = 0 ;
4152     int argvi = 0;
4153     dumpfile_t *result = 0 ;
4154     dXSARGS;
4155
4156     if ((items < 1) || (items > 1)) {
4157       SWIG_croak("Usage: C_from_string(string);");
4158     }
4159     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
4160     if (!SWIG_IsOK(res1)) {
4161       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "C_from_string" "', argument " "1"" of type '" "char const *""'");
4162     }
4163     arg1 = (char *)(buf1);
4164     result = (dumpfile_t *)C_from_string((char const *)arg1);
4165     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
4166     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4167     XSRETURN(argvi);
4168   fail:
4169     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4170     SWIG_croak_null();
4171   }
4172 }
4173
4174
4175
4176 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4177
4178 static swig_type_info _swigt__p_a_STRMAX__char = {"_p_a_STRMAX__char", "char (*)[STRMAX]|string_t *", 0, 0, (void*)0, 0};
4179 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
4180 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
4181 static swig_type_info _swigt__p_dumpfile_t = {"_p_dumpfile_t", "dumpfile_t *", 0, 0, (void*)"Amanda::Header::Header", 0};
4182 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
4183 static swig_type_info _swigt__p_int = {"_p_int", "int *|filetype_t *|gboolean *", 0, 0, (void*)0, 0};
4184 static swig_type_info _swigt__p_off_t = {"_p_off_t", "off_t *", 0, 0, (void*)0, 0};
4185 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
4186
4187 static swig_type_info *swig_type_initial[] = {
4188   &_swigt__p_a_STRMAX__char,
4189   &_swigt__p_char,
4190   &_swigt__p_double,
4191   &_swigt__p_dumpfile_t,
4192   &_swigt__p_float,
4193   &_swigt__p_int,
4194   &_swigt__p_off_t,
4195   &_swigt__p_unsigned_char,
4196 };
4197
4198 static swig_cast_info _swigc__p_a_STRMAX__char[] = {  {&_swigt__p_a_STRMAX__char, 0, 0, 0},{0, 0, 0, 0}};
4199 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
4200 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
4201 static swig_cast_info _swigc__p_dumpfile_t[] = {  {&_swigt__p_dumpfile_t, 0, 0, 0},{0, 0, 0, 0}};
4202 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
4203 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
4204 static swig_cast_info _swigc__p_off_t[] = {  {&_swigt__p_off_t, 0, 0, 0},{0, 0, 0, 0}};
4205 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
4206
4207 static swig_cast_info *swig_cast_initial[] = {
4208   _swigc__p_a_STRMAX__char,
4209   _swigc__p_char,
4210   _swigc__p_double,
4211   _swigc__p_dumpfile_t,
4212   _swigc__p_float,
4213   _swigc__p_int,
4214   _swigc__p_off_t,
4215   _swigc__p_unsigned_char,
4216 };
4217
4218
4219 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4220
4221 static swig_constant_info swig_constants[] = {
4222 {0,0,0,0,0,0}
4223 };
4224 #ifdef __cplusplus
4225 }
4226 #endif
4227 static swig_variable_info swig_variables[] = {
4228 {0,0,0,0}
4229 };
4230 static swig_command_info swig_commands[] = {
4231 {"Amanda::Headerc::Header_type_set", _wrap_Header_type_set},
4232 {"Amanda::Headerc::Header_type_get", _wrap_Header_type_get},
4233 {"Amanda::Headerc::Header_datestamp_set", _wrap_Header_datestamp_set},
4234 {"Amanda::Headerc::Header_datestamp_get", _wrap_Header_datestamp_get},
4235 {"Amanda::Headerc::Header_dumplevel_set", _wrap_Header_dumplevel_set},
4236 {"Amanda::Headerc::Header_dumplevel_get", _wrap_Header_dumplevel_get},
4237 {"Amanda::Headerc::Header_compressed_set", _wrap_Header_compressed_set},
4238 {"Amanda::Headerc::Header_compressed_get", _wrap_Header_compressed_get},
4239 {"Amanda::Headerc::Header_encrypted_set", _wrap_Header_encrypted_set},
4240 {"Amanda::Headerc::Header_encrypted_get", _wrap_Header_encrypted_get},
4241 {"Amanda::Headerc::Header_comp_suffix_set", _wrap_Header_comp_suffix_set},
4242 {"Amanda::Headerc::Header_comp_suffix_get", _wrap_Header_comp_suffix_get},
4243 {"Amanda::Headerc::Header_encrypt_suffix_set", _wrap_Header_encrypt_suffix_set},
4244 {"Amanda::Headerc::Header_encrypt_suffix_get", _wrap_Header_encrypt_suffix_get},
4245 {"Amanda::Headerc::Header_name_set", _wrap_Header_name_set},
4246 {"Amanda::Headerc::Header_name_get", _wrap_Header_name_get},
4247 {"Amanda::Headerc::Header_disk_set", _wrap_Header_disk_set},
4248 {"Amanda::Headerc::Header_disk_get", _wrap_Header_disk_get},
4249 {"Amanda::Headerc::Header_program_set", _wrap_Header_program_set},
4250 {"Amanda::Headerc::Header_program_get", _wrap_Header_program_get},
4251 {"Amanda::Headerc::Header_application_set", _wrap_Header_application_set},
4252 {"Amanda::Headerc::Header_application_get", _wrap_Header_application_get},
4253 {"Amanda::Headerc::Header_srvcompprog_set", _wrap_Header_srvcompprog_set},
4254 {"Amanda::Headerc::Header_srvcompprog_get", _wrap_Header_srvcompprog_get},
4255 {"Amanda::Headerc::Header_clntcompprog_set", _wrap_Header_clntcompprog_set},
4256 {"Amanda::Headerc::Header_clntcompprog_get", _wrap_Header_clntcompprog_get},
4257 {"Amanda::Headerc::Header_srv_encrypt_set", _wrap_Header_srv_encrypt_set},
4258 {"Amanda::Headerc::Header_srv_encrypt_get", _wrap_Header_srv_encrypt_get},
4259 {"Amanda::Headerc::Header_clnt_encrypt_set", _wrap_Header_clnt_encrypt_set},
4260 {"Amanda::Headerc::Header_clnt_encrypt_get", _wrap_Header_clnt_encrypt_get},
4261 {"Amanda::Headerc::Header_recover_cmd_set", _wrap_Header_recover_cmd_set},
4262 {"Amanda::Headerc::Header_recover_cmd_get", _wrap_Header_recover_cmd_get},
4263 {"Amanda::Headerc::Header_uncompress_cmd_set", _wrap_Header_uncompress_cmd_set},
4264 {"Amanda::Headerc::Header_uncompress_cmd_get", _wrap_Header_uncompress_cmd_get},
4265 {"Amanda::Headerc::Header_decrypt_cmd_set", _wrap_Header_decrypt_cmd_set},
4266 {"Amanda::Headerc::Header_decrypt_cmd_get", _wrap_Header_decrypt_cmd_get},
4267 {"Amanda::Headerc::Header_srv_decrypt_opt_set", _wrap_Header_srv_decrypt_opt_set},
4268 {"Amanda::Headerc::Header_srv_decrypt_opt_get", _wrap_Header_srv_decrypt_opt_get},
4269 {"Amanda::Headerc::Header_clnt_decrypt_opt_set", _wrap_Header_clnt_decrypt_opt_set},
4270 {"Amanda::Headerc::Header_clnt_decrypt_opt_get", _wrap_Header_clnt_decrypt_opt_get},
4271 {"Amanda::Headerc::Header_cont_filename_set", _wrap_Header_cont_filename_set},
4272 {"Amanda::Headerc::Header_cont_filename_get", _wrap_Header_cont_filename_get},
4273 {"Amanda::Headerc::Header_dle_str_set", _wrap_Header_dle_str_set},
4274 {"Amanda::Headerc::Header_dle_str_get", _wrap_Header_dle_str_get},
4275 {"Amanda::Headerc::Header_is_partial_set", _wrap_Header_is_partial_set},
4276 {"Amanda::Headerc::Header_is_partial_get", _wrap_Header_is_partial_get},
4277 {"Amanda::Headerc::Header_partnum_set", _wrap_Header_partnum_set},
4278 {"Amanda::Headerc::Header_partnum_get", _wrap_Header_partnum_get},
4279 {"Amanda::Headerc::Header_totalparts_set", _wrap_Header_totalparts_set},
4280 {"Amanda::Headerc::Header_totalparts_get", _wrap_Header_totalparts_get},
4281 {"Amanda::Headerc::Header_blocksize_set", _wrap_Header_blocksize_set},
4282 {"Amanda::Headerc::Header_blocksize_get", _wrap_Header_blocksize_get},
4283 {"Amanda::Headerc::Header_orig_size_set", _wrap_Header_orig_size_set},
4284 {"Amanda::Headerc::Header_orig_size_get", _wrap_Header_orig_size_get},
4285 {"Amanda::Headerc::new_Header", _wrap_new_Header},
4286 {"Amanda::Headerc::Header_to_string", _wrap_Header_to_string},
4287 {"Amanda::Headerc::Header_debug_dump", _wrap_Header_debug_dump},
4288 {"Amanda::Headerc::Header_summary", _wrap_Header_summary},
4289 {"Amanda::Headerc::delete_Header", _wrap_delete_Header},
4290 {"Amanda::Headerc::C_from_string", _wrap_C_from_string},
4291 {0,0}
4292 };
4293 /* -----------------------------------------------------------------------------
4294  * Type initialization:
4295  * This problem is tough by the requirement that no dynamic
4296  * memory is used. Also, since swig_type_info structures store pointers to
4297  * swig_cast_info structures and swig_cast_info structures store pointers back
4298  * to swig_type_info structures, we need some lookup code at initialization.
4299  * The idea is that swig generates all the structures that are needed.
4300  * The runtime then collects these partially filled structures.
4301  * The SWIG_InitializeModule function takes these initial arrays out of
4302  * swig_module, and does all the lookup, filling in the swig_module.types
4303  * array with the correct data and linking the correct swig_cast_info
4304  * structures together.
4305  *
4306  * The generated swig_type_info structures are assigned staticly to an initial
4307  * array. We just loop through that array, and handle each type individually.
4308  * First we lookup if this type has been already loaded, and if so, use the
4309  * loaded structure instead of the generated one. Then we have to fill in the
4310  * cast linked list. The cast data is initially stored in something like a
4311  * two-dimensional array. Each row corresponds to a type (there are the same
4312  * number of rows as there are in the swig_type_initial array). Each entry in
4313  * a column is one of the swig_cast_info structures for that type.
4314  * The cast_initial array is actually an array of arrays, because each row has
4315  * a variable number of columns. So to actually build the cast linked list,
4316  * we find the array of casts associated with the type, and loop through it
4317  * adding the casts to the list. The one last trick we need to do is making
4318  * sure the type pointer in the swig_cast_info struct is correct.
4319  *
4320  * First off, we lookup the cast->type name to see if it is already loaded.
4321  * There are three cases to handle:
4322  *  1) If the cast->type has already been loaded AND the type we are adding
4323  *     casting info to has not been loaded (it is in this module), THEN we
4324  *     replace the cast->type pointer with the type pointer that has already
4325  *     been loaded.
4326  *  2) If BOTH types (the one we are adding casting info to, and the
4327  *     cast->type) are loaded, THEN the cast info has already been loaded by
4328  *     the previous module so we just ignore it.
4329  *  3) Finally, if cast->type has not already been loaded, then we add that
4330  *     swig_cast_info to the linked list (because the cast->type) pointer will
4331  *     be correct.
4332  * ----------------------------------------------------------------------------- */
4333
4334 #ifdef __cplusplus
4335 extern "C" {
4336 #if 0
4337 } /* c-mode */
4338 #endif
4339 #endif
4340
4341 #if 0
4342 #define SWIGRUNTIME_DEBUG
4343 #endif
4344
4345
4346 SWIGRUNTIME void
4347 SWIG_InitializeModule(void *clientdata) {
4348   size_t i;
4349   swig_module_info *module_head, *iter;
4350   int found, init;
4351
4352   clientdata = clientdata;
4353
4354   /* check to see if the circular list has been setup, if not, set it up */
4355   if (swig_module.next==0) {
4356     /* Initialize the swig_module */
4357     swig_module.type_initial = swig_type_initial;
4358     swig_module.cast_initial = swig_cast_initial;
4359     swig_module.next = &swig_module;
4360     init = 1;
4361   } else {
4362     init = 0;
4363   }
4364
4365   /* Try and load any already created modules */
4366   module_head = SWIG_GetModule(clientdata);
4367   if (!module_head) {
4368     /* This is the first module loaded for this interpreter */
4369     /* so set the swig module into the interpreter */
4370     SWIG_SetModule(clientdata, &swig_module);
4371     module_head = &swig_module;
4372   } else {
4373     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4374     found=0;
4375     iter=module_head;
4376     do {
4377       if (iter==&swig_module) {
4378         found=1;
4379         break;
4380       }
4381       iter=iter->next;
4382     } while (iter!= module_head);
4383
4384     /* if the is found in the list, then all is done and we may leave */
4385     if (found) return;
4386     /* otherwise we must add out module into the list */
4387     swig_module.next = module_head->next;
4388     module_head->next = &swig_module;
4389   }
4390
4391   /* When multiple interpeters are used, a module could have already been initialized in
4392        a different interpreter, but not yet have a pointer in this interpreter.
4393        In this case, we do not want to continue adding types... everything should be
4394        set up already */
4395   if (init == 0) return;
4396
4397   /* Now work on filling in swig_module.types */
4398 #ifdef SWIGRUNTIME_DEBUG
4399   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
4400 #endif
4401   for (i = 0; i < swig_module.size; ++i) {
4402     swig_type_info *type = 0;
4403     swig_type_info *ret;
4404     swig_cast_info *cast;
4405
4406 #ifdef SWIGRUNTIME_DEBUG
4407     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4408 #endif
4409
4410     /* if there is another module already loaded */
4411     if (swig_module.next != &swig_module) {
4412       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4413     }
4414     if (type) {
4415       /* Overwrite clientdata field */
4416 #ifdef SWIGRUNTIME_DEBUG
4417       printf("SWIG_InitializeModule: found type %s\n", type->name);
4418 #endif
4419       if (swig_module.type_initial[i]->clientdata) {
4420         type->clientdata = swig_module.type_initial[i]->clientdata;
4421 #ifdef SWIGRUNTIME_DEBUG
4422         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
4423 #endif
4424       }
4425     } else {
4426       type = swig_module.type_initial[i];
4427     }
4428
4429     /* Insert casting types */
4430     cast = swig_module.cast_initial[i];
4431     while (cast->type) {
4432       /* Don't need to add information already in the list */
4433       ret = 0;
4434 #ifdef SWIGRUNTIME_DEBUG
4435       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4436 #endif
4437       if (swig_module.next != &swig_module) {
4438         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4439 #ifdef SWIGRUNTIME_DEBUG
4440         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4441 #endif
4442       }
4443       if (ret) {
4444         if (type == swig_module.type_initial[i]) {
4445 #ifdef SWIGRUNTIME_DEBUG
4446           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4447 #endif
4448           cast->type = ret;
4449           ret = 0;
4450         } else {
4451           /* Check for casting already in the list */
4452           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4453 #ifdef SWIGRUNTIME_DEBUG
4454           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4455 #endif
4456           if (!ocast) ret = 0;
4457         }
4458       }
4459
4460       if (!ret) {
4461 #ifdef SWIGRUNTIME_DEBUG
4462         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4463 #endif
4464         if (type->cast) {
4465           type->cast->prev = cast;
4466           cast->next = type->cast;
4467         }
4468         type->cast = cast;
4469       }
4470       cast++;
4471     }
4472     /* Set entry in modules->types array equal to the type */
4473     swig_module.types[i] = type;
4474   }
4475   swig_module.types[i] = 0;
4476
4477 #ifdef SWIGRUNTIME_DEBUG
4478   printf("**** SWIG_InitializeModule: Cast List ******\n");
4479   for (i = 0; i < swig_module.size; ++i) {
4480     int j = 0;
4481     swig_cast_info *cast = swig_module.cast_initial[i];
4482     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4483     while (cast->type) {
4484       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4485       cast++;
4486       ++j;
4487     }
4488     printf("---- Total casts: %d\n",j);
4489   }
4490   printf("**** SWIG_InitializeModule: Cast List ******\n");
4491 #endif
4492 }
4493
4494 /* This function will propagate the clientdata field of type to
4495 * any new swig_type_info structures that have been added into the list
4496 * of equivalent types.  It is like calling
4497 * SWIG_TypeClientData(type, clientdata) a second time.
4498 */
4499 SWIGRUNTIME void
4500 SWIG_PropagateClientData(void) {
4501   size_t i;
4502   swig_cast_info *equiv;
4503   static int init_run = 0;
4504
4505   if (init_run) return;
4506   init_run = 1;
4507
4508   for (i = 0; i < swig_module.size; i++) {
4509     if (swig_module.types[i]->clientdata) {
4510       equiv = swig_module.types[i]->cast;
4511       while (equiv) {
4512         if (!equiv->converter) {
4513           if (equiv->type && !equiv->type->clientdata)
4514           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4515         }
4516         equiv = equiv->next;
4517       }
4518     }
4519   }
4520 }
4521
4522 #ifdef __cplusplus
4523 #if 0
4524 {
4525   /* c-mode */
4526 #endif
4527 }
4528 #endif
4529
4530
4531
4532 #ifdef __cplusplus
4533 extern "C"
4534 #endif
4535
4536 XS(SWIG_init) {
4537   dXSARGS;
4538   int i;
4539
4540   SWIG_InitializeModule(0);
4541
4542   /* Install commands */
4543   for (i = 0; swig_commands[i].name; i++) {
4544     newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
4545   }
4546
4547   /* Install variables */
4548   for (i = 0; swig_variables[i].name; i++) {
4549     SV *sv;
4550     sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
4551     if (swig_variables[i].type) {
4552       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
4553     } else {
4554       sv_setiv(sv,(IV) 0);
4555     }
4556     swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
4557   }
4558
4559   /* Install constant */
4560   for (i = 0; swig_constants[i].type; i++) {
4561     SV *sv;
4562     sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
4563     switch(swig_constants[i].type) {
4564     case SWIG_INT:
4565       sv_setiv(sv, (IV) swig_constants[i].lvalue);
4566       break;
4567     case SWIG_FLOAT:
4568       sv_setnv(sv, (double) swig_constants[i].dvalue);
4569       break;
4570     case SWIG_STRING:
4571       sv_setpv(sv, (char *) swig_constants[i].pvalue);
4572       break;
4573     case SWIG_POINTER:
4574       SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
4575       break;
4576     case SWIG_BINARY:
4577       SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
4578       break;
4579     default:
4580       break;
4581     }
4582     SvREADONLY_on(sv);
4583   }
4584
4585   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4586     SV *sv = get_sv((char*) SWIG_prefix "F_UNKNOWN", TRUE | 0x2 | GV_ADDMULTI);
4587     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_UNKNOWN)));
4588     SvREADONLY_on(sv);
4589   } while(0) /*@SWIG@*/;
4590   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4591     SV *sv = get_sv((char*) SWIG_prefix "F_WEIRD", TRUE | 0x2 | GV_ADDMULTI);
4592     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_WEIRD)));
4593     SvREADONLY_on(sv);
4594   } while(0) /*@SWIG@*/;
4595   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4596     SV *sv = get_sv((char*) SWIG_prefix "F_TAPESTART", TRUE | 0x2 | GV_ADDMULTI);
4597     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_TAPESTART)));
4598     SvREADONLY_on(sv);
4599   } while(0) /*@SWIG@*/;
4600   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4601     SV *sv = get_sv((char*) SWIG_prefix "F_TAPEEND", TRUE | 0x2 | GV_ADDMULTI);
4602     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_TAPEEND)));
4603     SvREADONLY_on(sv);
4604   } while(0) /*@SWIG@*/;
4605   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4606     SV *sv = get_sv((char*) SWIG_prefix "F_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
4607     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_DUMPFILE)));
4608     SvREADONLY_on(sv);
4609   } while(0) /*@SWIG@*/;
4610   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4611     SV *sv = get_sv((char*) SWIG_prefix "F_CONT_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
4612     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_CONT_DUMPFILE)));
4613     SvREADONLY_on(sv);
4614   } while(0) /*@SWIG@*/;
4615   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4616     SV *sv = get_sv((char*) SWIG_prefix "F_SPLIT_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
4617     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_SPLIT_DUMPFILE)));
4618     SvREADONLY_on(sv);
4619   } while(0) /*@SWIG@*/;
4620   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4621     SV *sv = get_sv((char*) SWIG_prefix "F_EMPTY", TRUE | 0x2 | GV_ADDMULTI);
4622     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_EMPTY)));
4623     SvREADONLY_on(sv);
4624   } while(0) /*@SWIG@*/;
4625   SWIG_TypeClientData(SWIGTYPE_p_dumpfile_t, (void*) "Amanda::Header::Header");
4626   ST(0) = &PL_sv_yes;
4627   XSRETURN(1);
4628 }
4629