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_GSList swig_types[0]
1481 #define SWIGTYPE_p_a_STRMAX__char swig_types[1]
1482 #define SWIGTYPE_p_a_dle_s swig_types[2]
1483 #define SWIGTYPE_p_char swig_types[3]
1484 #define SWIGTYPE_p_data_path_t swig_types[4]
1485 #define SWIGTYPE_p_dle_t swig_types[5]
1486 #define SWIGTYPE_p_double swig_types[6]
1487 #define SWIGTYPE_p_dumpfile_t swig_types[7]
1488 #define SWIGTYPE_p_estimatelist_t swig_types[8]
1489 #define SWIGTYPE_p_float swig_types[9]
1490 #define SWIGTYPE_p_int swig_types[10]
1491 #define SWIGTYPE_p_levellist_t swig_types[11]
1492 #define SWIGTYPE_p_off_t swig_types[12]
1493 #define SWIGTYPE_p_proplist_t swig_types[13]
1494 #define SWIGTYPE_p_scriptlist_t swig_types[14]
1495 #define SWIGTYPE_p_sl_t swig_types[15]
1496 #define SWIGTYPE_p_unsigned_char swig_types[16]
1497 static swig_type_info *swig_types[18];
1498 static swig_module_info swig_module = {swig_types, 17, 0, 0, 0, 0};
1499 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1500 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1501
1502 /* -------- TYPES TABLE (END) -------- */
1503
1504 #define SWIG_init    boot_Amanda__Header
1505
1506 #define SWIG_name   "Amanda::Headerc::boot_Amanda__Header"
1507 #define SWIG_prefix "Amanda::Headerc::"
1508
1509 #define SWIGVERSION 0x010339
1510 #define SWIG_VERSION SWIGVERSION
1511
1512
1513 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1514 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1515
1516
1517 #ifdef __cplusplus
1518 extern "C"
1519 #endif
1520 #ifndef PERL_OBJECT
1521 #ifndef MULTIPLICITY
1522 SWIGEXPORT void SWIG_init (CV* cv);
1523 #else
1524 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1525 #endif
1526 #else
1527 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1528 #endif
1529
1530
1531 #include "amglue.h"
1532
1533
1534 #include "amglue.h"
1535
1536
1537 #include "amglue.h"
1538
1539
1540 #include "fileheader.h"
1541
1542
1543 SWIGINTERNINLINE SV *
1544 SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
1545 {
1546   SV *obj = sv_newmortal();
1547   sv_setiv(obj, (IV) value);
1548   return obj;
1549 }
1550
1551
1552 SWIGINTERNINLINE SV *
1553 SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
1554 {
1555   return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
1556 }
1557
1558
1559 #include <limits.h>
1560 #if !defined(SWIG_NO_LLONG_MAX)
1561 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1562 #   define LLONG_MAX __LONG_LONG_MAX__
1563 #   define LLONG_MIN (-LLONG_MAX - 1LL)
1564 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1565 # endif
1566 #endif
1567
1568
1569 SWIGINTERN int
1570 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1571 {
1572   if (SvNIOK(obj)) {
1573     if (val) *val = SvNV(obj);
1574     return SWIG_OK;
1575   } else if (SvIOK(obj)) {
1576     if (val) *val = (double) SvIV(obj);
1577     return SWIG_AddCast(SWIG_OK);
1578   } else {
1579     const char *nptr = SvPV_nolen(obj);
1580     if (nptr) {
1581       char *endptr;
1582       double v = strtod(nptr, &endptr);
1583       if (errno == ERANGE) {
1584         errno = 0;
1585         return SWIG_OverflowError;
1586       } else {
1587         if (*endptr == '\0') {
1588           if (val) *val = v;
1589           return SWIG_Str2NumCast(SWIG_OK);
1590         }
1591       }
1592     }
1593   }
1594   return SWIG_TypeError;
1595 }
1596
1597
1598 #include <float.h>
1599
1600
1601 #include <math.h>
1602
1603
1604 SWIGINTERNINLINE int
1605 SWIG_CanCastAsInteger(double *d, double min, double max) {
1606   double x = *d;
1607   if ((min <= x && x <= max)) {
1608    double fx = floor(x);
1609    double cx = ceil(x);
1610    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1611    if ((errno == EDOM) || (errno == ERANGE)) {
1612      errno = 0;
1613    } else {
1614      double summ, reps, diff;
1615      if (rd < x) {
1616        diff = x - rd;
1617      } else if (rd > x) {
1618        diff = rd - x;
1619      } else {
1620        return 1;
1621      }
1622      summ = rd + x;
1623      reps = diff/summ;
1624      if (reps < 8*DBL_EPSILON) {
1625        *d = rd;
1626        return 1;
1627      }
1628    }
1629   }
1630   return 0;
1631 }
1632
1633
1634 SWIGINTERN int
1635 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1636 {
1637   if (SvIOK(obj)) {
1638     if (val) *val = SvIV(obj);
1639     return SWIG_OK;
1640   } else {
1641     int dispatch = 0;
1642     const char *nptr = SvPV_nolen(obj);
1643     if (nptr) {
1644       char *endptr;
1645       long v;
1646       errno = 0;
1647       v = strtol(nptr, &endptr,0);
1648       if (errno == ERANGE) {
1649         errno = 0;
1650         return SWIG_OverflowError;
1651       } else {
1652         if (*endptr == '\0') {
1653           if (val) *val = v;
1654           return SWIG_Str2NumCast(SWIG_OK);
1655         }
1656       }
1657     }
1658     if (!dispatch) {
1659       double d;
1660       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1661       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1662         if (val) *val = (long)(d);
1663         return res;
1664       }
1665     }
1666   }
1667   return SWIG_TypeError;
1668 }
1669
1670
1671 SWIGINTERN int
1672 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1673 {
1674   long v;
1675   int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1676   if (SWIG_IsOK(res)) {
1677     if ((v < INT_MIN || v > INT_MAX)) {
1678       return SWIG_OverflowError;
1679     } else {
1680       if (val) *val = (int)(v);
1681     }
1682   }
1683   return res;
1684 }
1685
1686
1687 SWIGINTERN swig_type_info*
1688 SWIG_pchar_descriptor(void)
1689 {
1690   static int init = 0;
1691   static swig_type_info* info = 0;
1692   if (!init) {
1693     info = SWIG_TypeQuery("_p_char");
1694     init = 1;
1695   }
1696   return info;
1697 }
1698
1699
1700 SWIGINTERN int
1701 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1702 {
1703   if (SvMAGICAL(obj)) {
1704      SV *tmp = sv_newmortal();
1705      SvSetSV(tmp, obj);
1706      obj = tmp;
1707   }
1708   if (SvPOK(obj)) {
1709     STRLEN len = 0;
1710     char *cstr = SvPV(obj, len);
1711     size_t size = len + 1;
1712     if (cptr)  {
1713       if (alloc) {
1714         if (*alloc == SWIG_NEWOBJ) {
1715           *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1716         } else {
1717           *cptr = cstr;
1718           *alloc = SWIG_OLDOBJ;
1719         }
1720       }
1721     }
1722     if (psize) *psize = size;
1723     return SWIG_OK;
1724   } else {
1725     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1726     if (pchar_descriptor) {
1727       char* vptr = 0;
1728       if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1729         if (cptr) *cptr = vptr;
1730         if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1731         if (alloc) *alloc = SWIG_OLDOBJ;
1732         return SWIG_OK;
1733       }
1734     }
1735   }
1736   return SWIG_TypeError;
1737 }
1738
1739
1740 SWIGINTERN int
1741 SWIG_AsCharArray(SV * obj, char *val, size_t size)
1742 {
1743   char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
1744   int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
1745   if (SWIG_IsOK(res)) {
1746     if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
1747     if (csize <= size) {
1748       if (val) {
1749         if (csize) memcpy(val, cptr, csize*sizeof(char));
1750         if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
1751       }
1752       if (alloc == SWIG_NEWOBJ) {
1753         free((char*)cptr);
1754         res = SWIG_DelNewMask(res);
1755       }
1756       return res;
1757     }
1758     if (alloc == SWIG_NEWOBJ) free((char*)cptr);
1759   }
1760   return SWIG_TypeError;
1761 }
1762
1763
1764 SWIGINTERNINLINE SV *
1765 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1766 {
1767   SV *obj = sv_newmortal();
1768   if (carray) {
1769     sv_setpvn(obj, carray, size);
1770   } else {
1771     sv_setsv(obj, &PL_sv_undef);
1772   }
1773   return obj;
1774 }
1775
1776
1777
1778
1779
1780 SWIGINTERNINLINE SV *
1781 SWIG_FromCharPtr(const char *cptr)
1782 {
1783   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1784 }
1785
1786
1787 SWIGINTERN int
1788 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
1789 {
1790   if (SvUOK(obj)) {
1791     if (val) *val = SvUV(obj);
1792     return SWIG_OK;
1793   } else  if (SvIOK(obj)) {
1794     long v = SvIV(obj);
1795     if (v >= 0) {
1796       if (val) *val = v;
1797       return SWIG_OK;
1798     } else {
1799       return SWIG_OverflowError;
1800     }
1801   } else {
1802     int dispatch = 0;
1803     const char *nptr = SvPV_nolen(obj);
1804     if (nptr) {
1805       char *endptr;
1806       unsigned long v;
1807       errno = 0;
1808       v = strtoul(nptr, &endptr,0);
1809       if (errno == ERANGE) {
1810         errno = 0;
1811         return SWIG_OverflowError;
1812       } else {
1813         if (*endptr == '\0') {
1814           if (val) *val = v;
1815           return SWIG_Str2NumCast(SWIG_OK);
1816         }
1817       }
1818     }
1819     if (!dispatch) {
1820       double d;
1821       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1822       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
1823         if (val) *val = (unsigned long)(d);
1824         return res;
1825       }
1826     }
1827   }
1828   return SWIG_TypeError;
1829 }
1830
1831
1832 SWIGINTERNINLINE int
1833 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
1834 {
1835   unsigned long v;
1836   int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
1837   if (SWIG_IsOK(res) && val) *val = (size_t)(v);
1838   return res;
1839 }
1840
1841 SWIGINTERN dumpfile_t *new_dumpfile_t(){
1842             dumpfile_t *df = g_new(dumpfile_t, 1);
1843             fh_init(df);
1844             /* some default values */
1845             df->totalparts = -1;
1846             df->partnum = 1;
1847             return df;
1848         }
1849 SWIGINTERN SV *dumpfile_t_to_string(dumpfile_t *self,size_t min_size,size_t max_size){
1850             size_t size = min_size;
1851             char *result;
1852
1853             result = build_header(self, &size, max_size);
1854             if (!result) {
1855                 /* header didn't fit -> return undef; */
1856                 return &PL_sv_undef;
1857             } else {
1858                 STRLEN strlen_size = (STRLEN)size;
1859                 SV *sv;
1860                 g_assert((size_t)strlen_size == size); /* check for casting overflow */
1861                 sv = sv_2mortal(newSVpvn(result, (STRLEN)size));
1862                 g_free(result);
1863                 return sv;
1864             }
1865         }
1866 SWIGINTERN void dumpfile_t_debug_dump(dumpfile_t *self){
1867             dump_dumpfile_t(self);
1868         }
1869 SWIGINTERN char *dumpfile_t_summary(dumpfile_t *self){
1870             return summarize_header(self);
1871         }
1872
1873 static dumpfile_t *C_from_string(const char *string) {
1874     dumpfile_t *result = g_new(dumpfile_t, 1);
1875     parse_file_header(string, result, strlen(string));
1876     return result;
1877 }
1878
1879
1880 #include "amxml.h"
1881
1882 SWIGINTERN dle_t *new_dle_t(char *dle_str){
1883             char  *errmsg = NULL;
1884             dle_t *dle;
1885             dle = amxml_parse_node_CHAR(dle_str, &errmsg);
1886             amfree(errmsg);
1887
1888             return dle;
1889         }
1890 #ifdef __cplusplus
1891 extern "C" {
1892 #endif
1893
1894 #ifdef PERL_OBJECT
1895 #define MAGIC_CLASS _wrap_Amanda__Header_var::
1896 class _wrap_Amanda__Header_var : public CPerlObj {
1897 public:
1898 #else
1899 #define MAGIC_CLASS
1900 #endif
1901 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
1902     MAGIC_PPERL
1903     croak("Value is read-only.");
1904     return 0;
1905 }
1906
1907
1908 #ifdef PERL_OBJECT
1909 };
1910 #endif
1911
1912 #ifdef __cplusplus
1913 }
1914 #endif
1915
1916 #ifdef __cplusplus
1917 extern "C" {
1918 #endif
1919 XS(_wrap_Header_type_set) {
1920   {
1921     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1922     filetype_t arg2 ;
1923     void *argp1 = 0 ;
1924     int res1 = 0 ;
1925     int argvi = 0;
1926     dXSARGS;
1927
1928     if ((items < 2) || (items > 2)) {
1929       SWIG_croak("Usage: Header_type_set(self,type);");
1930     }
1931     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
1932     if (!SWIG_IsOK(res1)) {
1933       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_type_set" "', argument " "1"" of type '" "dumpfile_t *""'");
1934     }
1935     arg1 = (dumpfile_t *)(argp1);
1936     {
1937       if (sizeof(signed int) == 1) {
1938         arg2 = amglue_SvI8(ST(1));
1939       } else if (sizeof(signed int) == 2) {
1940         arg2 = amglue_SvI16(ST(1));
1941       } else if (sizeof(signed int) == 4) {
1942         arg2 = amglue_SvI32(ST(1));
1943       } else if (sizeof(signed int) == 8) {
1944         arg2 = amglue_SvI64(ST(1));
1945       } else {
1946         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
1947       }
1948     }
1949     if (arg1) (arg1)->type = arg2;
1950     ST(argvi) = sv_newmortal();
1951
1952
1953     XSRETURN(argvi);
1954   fail:
1955
1956
1957     SWIG_croak_null();
1958   }
1959 }
1960
1961
1962 XS(_wrap_Header_type_get) {
1963   {
1964     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1965     void *argp1 = 0 ;
1966     int res1 = 0 ;
1967     int argvi = 0;
1968     filetype_t result;
1969     dXSARGS;
1970
1971     if ((items < 1) || (items > 1)) {
1972       SWIG_croak("Usage: Header_type_get(self);");
1973     }
1974     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
1975     if (!SWIG_IsOK(res1)) {
1976       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_type_get" "', argument " "1"" of type '" "dumpfile_t *""'");
1977     }
1978     arg1 = (dumpfile_t *)(argp1);
1979     result = (filetype_t) ((arg1)->type);
1980     {
1981       SV *for_stack;
1982       SP += argvi; PUTBACK;
1983       for_stack = sv_2mortal(amglue_newSVi64(result));
1984       SPAGAIN; SP -= argvi;
1985       ST(argvi) = for_stack;
1986       argvi++;
1987     }
1988
1989     XSRETURN(argvi);
1990   fail:
1991
1992     SWIG_croak_null();
1993   }
1994 }
1995
1996
1997 XS(_wrap_Header_datestamp_set) {
1998   {
1999     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2000     char *arg2 ;
2001     void *argp1 = 0 ;
2002     int res1 = 0 ;
2003     char temp2[STRMAX] ;
2004     int res2 ;
2005     int argvi = 0;
2006     dXSARGS;
2007
2008     if ((items < 2) || (items > 2)) {
2009       SWIG_croak("Usage: Header_datestamp_set(self,datestamp);");
2010     }
2011     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2012     if (!SWIG_IsOK(res1)) {
2013       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_datestamp_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2014     }
2015     arg1 = (dumpfile_t *)(argp1);
2016     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2017     if (!SWIG_IsOK(res2)) {
2018       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_datestamp_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2019     }
2020     arg2 = (char *)(temp2);
2021     {
2022       strncpy(arg1->datestamp, arg2, STRMAX);
2023       if (arg1->datestamp[STRMAX-1] != '\0')
2024       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2025     }
2026     ST(argvi) = sv_newmortal();
2027
2028
2029     XSRETURN(argvi);
2030   fail:
2031
2032
2033     SWIG_croak_null();
2034   }
2035 }
2036
2037
2038 XS(_wrap_Header_datestamp_get) {
2039   {
2040     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2041     void *argp1 = 0 ;
2042     int res1 = 0 ;
2043     int argvi = 0;
2044     char *result = 0 ;
2045     dXSARGS;
2046
2047     if ((items < 1) || (items > 1)) {
2048       SWIG_croak("Usage: Header_datestamp_get(self);");
2049     }
2050     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2051     if (!SWIG_IsOK(res1)) {
2052       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_datestamp_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2053     }
2054     arg1 = (dumpfile_t *)(argp1);
2055     result = (char *) ((arg1)->datestamp);
2056     {
2057       size_t size = STRMAX;
2058
2059       while (size && (result[size - 1] == '\0')) --size;
2060
2061       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2062     }
2063
2064     XSRETURN(argvi);
2065   fail:
2066
2067     SWIG_croak_null();
2068   }
2069 }
2070
2071
2072 XS(_wrap_Header_dumplevel_set) {
2073   {
2074     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2075     int arg2 ;
2076     void *argp1 = 0 ;
2077     int res1 = 0 ;
2078     int argvi = 0;
2079     dXSARGS;
2080
2081     if ((items < 2) || (items > 2)) {
2082       SWIG_croak("Usage: Header_dumplevel_set(self,dumplevel);");
2083     }
2084     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2085     if (!SWIG_IsOK(res1)) {
2086       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dumplevel_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2087     }
2088     arg1 = (dumpfile_t *)(argp1);
2089     {
2090       if (sizeof(signed int) == 1) {
2091         arg2 = amglue_SvI8(ST(1));
2092       } else if (sizeof(signed int) == 2) {
2093         arg2 = amglue_SvI16(ST(1));
2094       } else if (sizeof(signed int) == 4) {
2095         arg2 = amglue_SvI32(ST(1));
2096       } else if (sizeof(signed int) == 8) {
2097         arg2 = amglue_SvI64(ST(1));
2098       } else {
2099         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2100       }
2101     }
2102     if (arg1) (arg1)->dumplevel = arg2;
2103     ST(argvi) = sv_newmortal();
2104
2105
2106     XSRETURN(argvi);
2107   fail:
2108
2109
2110     SWIG_croak_null();
2111   }
2112 }
2113
2114
2115 XS(_wrap_Header_dumplevel_get) {
2116   {
2117     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2118     void *argp1 = 0 ;
2119     int res1 = 0 ;
2120     int argvi = 0;
2121     int result;
2122     dXSARGS;
2123
2124     if ((items < 1) || (items > 1)) {
2125       SWIG_croak("Usage: Header_dumplevel_get(self);");
2126     }
2127     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2128     if (!SWIG_IsOK(res1)) {
2129       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dumplevel_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2130     }
2131     arg1 = (dumpfile_t *)(argp1);
2132     result = (int) ((arg1)->dumplevel);
2133     {
2134       SV *for_stack;
2135       SP += argvi; PUTBACK;
2136       for_stack = sv_2mortal(amglue_newSVi64(result));
2137       SPAGAIN; SP -= argvi;
2138       ST(argvi) = for_stack;
2139       argvi++;
2140     }
2141
2142     XSRETURN(argvi);
2143   fail:
2144
2145     SWIG_croak_null();
2146   }
2147 }
2148
2149
2150 XS(_wrap_Header_compressed_set) {
2151   {
2152     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2153     int arg2 ;
2154     void *argp1 = 0 ;
2155     int res1 = 0 ;
2156     int argvi = 0;
2157     dXSARGS;
2158
2159     if ((items < 2) || (items > 2)) {
2160       SWIG_croak("Usage: Header_compressed_set(self,compressed);");
2161     }
2162     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2163     if (!SWIG_IsOK(res1)) {
2164       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_compressed_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2165     }
2166     arg1 = (dumpfile_t *)(argp1);
2167     {
2168       if (sizeof(signed int) == 1) {
2169         arg2 = amglue_SvI8(ST(1));
2170       } else if (sizeof(signed int) == 2) {
2171         arg2 = amglue_SvI16(ST(1));
2172       } else if (sizeof(signed int) == 4) {
2173         arg2 = amglue_SvI32(ST(1));
2174       } else if (sizeof(signed int) == 8) {
2175         arg2 = amglue_SvI64(ST(1));
2176       } else {
2177         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2178       }
2179     }
2180     if (arg1) (arg1)->compressed = arg2;
2181     ST(argvi) = sv_newmortal();
2182
2183
2184     XSRETURN(argvi);
2185   fail:
2186
2187
2188     SWIG_croak_null();
2189   }
2190 }
2191
2192
2193 XS(_wrap_Header_compressed_get) {
2194   {
2195     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2196     void *argp1 = 0 ;
2197     int res1 = 0 ;
2198     int argvi = 0;
2199     int result;
2200     dXSARGS;
2201
2202     if ((items < 1) || (items > 1)) {
2203       SWIG_croak("Usage: Header_compressed_get(self);");
2204     }
2205     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2206     if (!SWIG_IsOK(res1)) {
2207       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_compressed_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2208     }
2209     arg1 = (dumpfile_t *)(argp1);
2210     result = (int) ((arg1)->compressed);
2211     {
2212       SV *for_stack;
2213       SP += argvi; PUTBACK;
2214       for_stack = sv_2mortal(amglue_newSVi64(result));
2215       SPAGAIN; SP -= argvi;
2216       ST(argvi) = for_stack;
2217       argvi++;
2218     }
2219
2220     XSRETURN(argvi);
2221   fail:
2222
2223     SWIG_croak_null();
2224   }
2225 }
2226
2227
2228 XS(_wrap_Header_encrypted_set) {
2229   {
2230     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2231     int arg2 ;
2232     void *argp1 = 0 ;
2233     int res1 = 0 ;
2234     int argvi = 0;
2235     dXSARGS;
2236
2237     if ((items < 2) || (items > 2)) {
2238       SWIG_croak("Usage: Header_encrypted_set(self,encrypted);");
2239     }
2240     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2241     if (!SWIG_IsOK(res1)) {
2242       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypted_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2243     }
2244     arg1 = (dumpfile_t *)(argp1);
2245     {
2246       if (sizeof(signed int) == 1) {
2247         arg2 = amglue_SvI8(ST(1));
2248       } else if (sizeof(signed int) == 2) {
2249         arg2 = amglue_SvI16(ST(1));
2250       } else if (sizeof(signed int) == 4) {
2251         arg2 = amglue_SvI32(ST(1));
2252       } else if (sizeof(signed int) == 8) {
2253         arg2 = amglue_SvI64(ST(1));
2254       } else {
2255         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2256       }
2257     }
2258     if (arg1) (arg1)->encrypted = arg2;
2259     ST(argvi) = sv_newmortal();
2260
2261
2262     XSRETURN(argvi);
2263   fail:
2264
2265
2266     SWIG_croak_null();
2267   }
2268 }
2269
2270
2271 XS(_wrap_Header_encrypted_get) {
2272   {
2273     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2274     void *argp1 = 0 ;
2275     int res1 = 0 ;
2276     int argvi = 0;
2277     int result;
2278     dXSARGS;
2279
2280     if ((items < 1) || (items > 1)) {
2281       SWIG_croak("Usage: Header_encrypted_get(self);");
2282     }
2283     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2284     if (!SWIG_IsOK(res1)) {
2285       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypted_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2286     }
2287     arg1 = (dumpfile_t *)(argp1);
2288     result = (int) ((arg1)->encrypted);
2289     {
2290       SV *for_stack;
2291       SP += argvi; PUTBACK;
2292       for_stack = sv_2mortal(amglue_newSVi64(result));
2293       SPAGAIN; SP -= argvi;
2294       ST(argvi) = for_stack;
2295       argvi++;
2296     }
2297
2298     XSRETURN(argvi);
2299   fail:
2300
2301     SWIG_croak_null();
2302   }
2303 }
2304
2305
2306 XS(_wrap_Header_comp_suffix_set) {
2307   {
2308     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2309     char *arg2 ;
2310     void *argp1 = 0 ;
2311     int res1 = 0 ;
2312     char temp2[STRMAX] ;
2313     int res2 ;
2314     int argvi = 0;
2315     dXSARGS;
2316
2317     if ((items < 2) || (items > 2)) {
2318       SWIG_croak("Usage: Header_comp_suffix_set(self,comp_suffix);");
2319     }
2320     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2321     if (!SWIG_IsOK(res1)) {
2322       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_comp_suffix_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2323     }
2324     arg1 = (dumpfile_t *)(argp1);
2325     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2326     if (!SWIG_IsOK(res2)) {
2327       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_comp_suffix_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2328     }
2329     arg2 = (char *)(temp2);
2330     {
2331       strncpy(arg1->comp_suffix, arg2, STRMAX);
2332       if (arg1->comp_suffix[STRMAX-1] != '\0')
2333       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2334     }
2335     ST(argvi) = sv_newmortal();
2336
2337
2338     XSRETURN(argvi);
2339   fail:
2340
2341
2342     SWIG_croak_null();
2343   }
2344 }
2345
2346
2347 XS(_wrap_Header_comp_suffix_get) {
2348   {
2349     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2350     void *argp1 = 0 ;
2351     int res1 = 0 ;
2352     int argvi = 0;
2353     char *result = 0 ;
2354     dXSARGS;
2355
2356     if ((items < 1) || (items > 1)) {
2357       SWIG_croak("Usage: Header_comp_suffix_get(self);");
2358     }
2359     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2360     if (!SWIG_IsOK(res1)) {
2361       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_comp_suffix_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2362     }
2363     arg1 = (dumpfile_t *)(argp1);
2364     result = (char *) ((arg1)->comp_suffix);
2365     {
2366       size_t size = STRMAX;
2367
2368       while (size && (result[size - 1] == '\0')) --size;
2369
2370       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2371     }
2372
2373     XSRETURN(argvi);
2374   fail:
2375
2376     SWIG_croak_null();
2377   }
2378 }
2379
2380
2381 XS(_wrap_Header_encrypt_suffix_set) {
2382   {
2383     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2384     char *arg2 ;
2385     void *argp1 = 0 ;
2386     int res1 = 0 ;
2387     char temp2[STRMAX] ;
2388     int res2 ;
2389     int argvi = 0;
2390     dXSARGS;
2391
2392     if ((items < 2) || (items > 2)) {
2393       SWIG_croak("Usage: Header_encrypt_suffix_set(self,encrypt_suffix);");
2394     }
2395     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2396     if (!SWIG_IsOK(res1)) {
2397       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypt_suffix_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2398     }
2399     arg1 = (dumpfile_t *)(argp1);
2400     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2401     if (!SWIG_IsOK(res2)) {
2402       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_encrypt_suffix_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2403     }
2404     arg2 = (char *)(temp2);
2405     {
2406       strncpy(arg1->encrypt_suffix, arg2, STRMAX);
2407       if (arg1->encrypt_suffix[STRMAX-1] != '\0')
2408       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2409     }
2410     ST(argvi) = sv_newmortal();
2411
2412
2413     XSRETURN(argvi);
2414   fail:
2415
2416
2417     SWIG_croak_null();
2418   }
2419 }
2420
2421
2422 XS(_wrap_Header_encrypt_suffix_get) {
2423   {
2424     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2425     void *argp1 = 0 ;
2426     int res1 = 0 ;
2427     int argvi = 0;
2428     char *result = 0 ;
2429     dXSARGS;
2430
2431     if ((items < 1) || (items > 1)) {
2432       SWIG_croak("Usage: Header_encrypt_suffix_get(self);");
2433     }
2434     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2435     if (!SWIG_IsOK(res1)) {
2436       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypt_suffix_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2437     }
2438     arg1 = (dumpfile_t *)(argp1);
2439     result = (char *) ((arg1)->encrypt_suffix);
2440     {
2441       size_t size = STRMAX;
2442
2443       while (size && (result[size - 1] == '\0')) --size;
2444
2445       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2446     }
2447
2448     XSRETURN(argvi);
2449   fail:
2450
2451     SWIG_croak_null();
2452   }
2453 }
2454
2455
2456 XS(_wrap_Header_name_set) {
2457   {
2458     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2459     char *arg2 ;
2460     void *argp1 = 0 ;
2461     int res1 = 0 ;
2462     char temp2[STRMAX] ;
2463     int res2 ;
2464     int argvi = 0;
2465     dXSARGS;
2466
2467     if ((items < 2) || (items > 2)) {
2468       SWIG_croak("Usage: Header_name_set(self,name);");
2469     }
2470     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2471     if (!SWIG_IsOK(res1)) {
2472       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_name_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2473     }
2474     arg1 = (dumpfile_t *)(argp1);
2475     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2476     if (!SWIG_IsOK(res2)) {
2477       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_name_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2478     }
2479     arg2 = (char *)(temp2);
2480     {
2481       strncpy(arg1->name, arg2, STRMAX);
2482       if (arg1->name[STRMAX-1] != '\0')
2483       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2484     }
2485     ST(argvi) = sv_newmortal();
2486
2487
2488     XSRETURN(argvi);
2489   fail:
2490
2491
2492     SWIG_croak_null();
2493   }
2494 }
2495
2496
2497 XS(_wrap_Header_name_get) {
2498   {
2499     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2500     void *argp1 = 0 ;
2501     int res1 = 0 ;
2502     int argvi = 0;
2503     char *result = 0 ;
2504     dXSARGS;
2505
2506     if ((items < 1) || (items > 1)) {
2507       SWIG_croak("Usage: Header_name_get(self);");
2508     }
2509     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2510     if (!SWIG_IsOK(res1)) {
2511       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_name_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2512     }
2513     arg1 = (dumpfile_t *)(argp1);
2514     result = (char *) ((arg1)->name);
2515     {
2516       size_t size = STRMAX;
2517
2518       while (size && (result[size - 1] == '\0')) --size;
2519
2520       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2521     }
2522
2523     XSRETURN(argvi);
2524   fail:
2525
2526     SWIG_croak_null();
2527   }
2528 }
2529
2530
2531 XS(_wrap_Header_disk_set) {
2532   {
2533     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2534     char *arg2 ;
2535     void *argp1 = 0 ;
2536     int res1 = 0 ;
2537     char temp2[STRMAX] ;
2538     int res2 ;
2539     int argvi = 0;
2540     dXSARGS;
2541
2542     if ((items < 2) || (items > 2)) {
2543       SWIG_croak("Usage: Header_disk_set(self,disk);");
2544     }
2545     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2546     if (!SWIG_IsOK(res1)) {
2547       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_disk_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2548     }
2549     arg1 = (dumpfile_t *)(argp1);
2550     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2551     if (!SWIG_IsOK(res2)) {
2552       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_disk_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2553     }
2554     arg2 = (char *)(temp2);
2555     {
2556       strncpy(arg1->disk, arg2, STRMAX);
2557       if (arg1->disk[STRMAX-1] != '\0')
2558       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2559     }
2560     ST(argvi) = sv_newmortal();
2561
2562
2563     XSRETURN(argvi);
2564   fail:
2565
2566
2567     SWIG_croak_null();
2568   }
2569 }
2570
2571
2572 XS(_wrap_Header_disk_get) {
2573   {
2574     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2575     void *argp1 = 0 ;
2576     int res1 = 0 ;
2577     int argvi = 0;
2578     char *result = 0 ;
2579     dXSARGS;
2580
2581     if ((items < 1) || (items > 1)) {
2582       SWIG_croak("Usage: Header_disk_get(self);");
2583     }
2584     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2585     if (!SWIG_IsOK(res1)) {
2586       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_disk_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2587     }
2588     arg1 = (dumpfile_t *)(argp1);
2589     result = (char *) ((arg1)->disk);
2590     {
2591       size_t size = STRMAX;
2592
2593       while (size && (result[size - 1] == '\0')) --size;
2594
2595       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2596     }
2597
2598     XSRETURN(argvi);
2599   fail:
2600
2601     SWIG_croak_null();
2602   }
2603 }
2604
2605
2606 XS(_wrap_Header_program_set) {
2607   {
2608     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2609     char *arg2 ;
2610     void *argp1 = 0 ;
2611     int res1 = 0 ;
2612     char temp2[STRMAX] ;
2613     int res2 ;
2614     int argvi = 0;
2615     dXSARGS;
2616
2617     if ((items < 2) || (items > 2)) {
2618       SWIG_croak("Usage: Header_program_set(self,program);");
2619     }
2620     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2621     if (!SWIG_IsOK(res1)) {
2622       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_program_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2623     }
2624     arg1 = (dumpfile_t *)(argp1);
2625     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2626     if (!SWIG_IsOK(res2)) {
2627       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_program_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2628     }
2629     arg2 = (char *)(temp2);
2630     {
2631       strncpy(arg1->program, arg2, STRMAX);
2632       if (arg1->program[STRMAX-1] != '\0')
2633       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2634     }
2635     ST(argvi) = sv_newmortal();
2636
2637
2638     XSRETURN(argvi);
2639   fail:
2640
2641
2642     SWIG_croak_null();
2643   }
2644 }
2645
2646
2647 XS(_wrap_Header_program_get) {
2648   {
2649     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2650     void *argp1 = 0 ;
2651     int res1 = 0 ;
2652     int argvi = 0;
2653     char *result = 0 ;
2654     dXSARGS;
2655
2656     if ((items < 1) || (items > 1)) {
2657       SWIG_croak("Usage: Header_program_get(self);");
2658     }
2659     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2660     if (!SWIG_IsOK(res1)) {
2661       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_program_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2662     }
2663     arg1 = (dumpfile_t *)(argp1);
2664     result = (char *) ((arg1)->program);
2665     {
2666       size_t size = STRMAX;
2667
2668       while (size && (result[size - 1] == '\0')) --size;
2669
2670       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2671     }
2672
2673     XSRETURN(argvi);
2674   fail:
2675
2676     SWIG_croak_null();
2677   }
2678 }
2679
2680
2681 XS(_wrap_Header_application_set) {
2682   {
2683     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2684     char *arg2 ;
2685     void *argp1 = 0 ;
2686     int res1 = 0 ;
2687     char temp2[STRMAX] ;
2688     int res2 ;
2689     int argvi = 0;
2690     dXSARGS;
2691
2692     if ((items < 2) || (items > 2)) {
2693       SWIG_croak("Usage: Header_application_set(self,application);");
2694     }
2695     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2696     if (!SWIG_IsOK(res1)) {
2697       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_application_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2698     }
2699     arg1 = (dumpfile_t *)(argp1);
2700     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2701     if (!SWIG_IsOK(res2)) {
2702       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_application_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2703     }
2704     arg2 = (char *)(temp2);
2705     {
2706       strncpy(arg1->application, arg2, STRMAX);
2707       if (arg1->application[STRMAX-1] != '\0')
2708       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2709     }
2710     ST(argvi) = sv_newmortal();
2711
2712
2713     XSRETURN(argvi);
2714   fail:
2715
2716
2717     SWIG_croak_null();
2718   }
2719 }
2720
2721
2722 XS(_wrap_Header_application_get) {
2723   {
2724     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2725     void *argp1 = 0 ;
2726     int res1 = 0 ;
2727     int argvi = 0;
2728     char *result = 0 ;
2729     dXSARGS;
2730
2731     if ((items < 1) || (items > 1)) {
2732       SWIG_croak("Usage: Header_application_get(self);");
2733     }
2734     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2735     if (!SWIG_IsOK(res1)) {
2736       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_application_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2737     }
2738     arg1 = (dumpfile_t *)(argp1);
2739     result = (char *) ((arg1)->application);
2740     {
2741       size_t size = STRMAX;
2742
2743       while (size && (result[size - 1] == '\0')) --size;
2744
2745       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2746     }
2747
2748     XSRETURN(argvi);
2749   fail:
2750
2751     SWIG_croak_null();
2752   }
2753 }
2754
2755
2756 XS(_wrap_Header_srvcompprog_set) {
2757   {
2758     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2759     char *arg2 ;
2760     void *argp1 = 0 ;
2761     int res1 = 0 ;
2762     char temp2[STRMAX] ;
2763     int res2 ;
2764     int argvi = 0;
2765     dXSARGS;
2766
2767     if ((items < 2) || (items > 2)) {
2768       SWIG_croak("Usage: Header_srvcompprog_set(self,srvcompprog);");
2769     }
2770     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2771     if (!SWIG_IsOK(res1)) {
2772       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srvcompprog_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2773     }
2774     arg1 = (dumpfile_t *)(argp1);
2775     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2776     if (!SWIG_IsOK(res2)) {
2777       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srvcompprog_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2778     }
2779     arg2 = (char *)(temp2);
2780     {
2781       strncpy(arg1->srvcompprog, arg2, STRMAX);
2782       if (arg1->srvcompprog[STRMAX-1] != '\0')
2783       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2784     }
2785     ST(argvi) = sv_newmortal();
2786
2787
2788     XSRETURN(argvi);
2789   fail:
2790
2791
2792     SWIG_croak_null();
2793   }
2794 }
2795
2796
2797 XS(_wrap_Header_srvcompprog_get) {
2798   {
2799     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2800     void *argp1 = 0 ;
2801     int res1 = 0 ;
2802     int argvi = 0;
2803     char *result = 0 ;
2804     dXSARGS;
2805
2806     if ((items < 1) || (items > 1)) {
2807       SWIG_croak("Usage: Header_srvcompprog_get(self);");
2808     }
2809     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2810     if (!SWIG_IsOK(res1)) {
2811       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srvcompprog_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2812     }
2813     arg1 = (dumpfile_t *)(argp1);
2814     result = (char *) ((arg1)->srvcompprog);
2815     {
2816       size_t size = STRMAX;
2817
2818       while (size && (result[size - 1] == '\0')) --size;
2819
2820       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2821     }
2822
2823     XSRETURN(argvi);
2824   fail:
2825
2826     SWIG_croak_null();
2827   }
2828 }
2829
2830
2831 XS(_wrap_Header_clntcompprog_set) {
2832   {
2833     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2834     char *arg2 ;
2835     void *argp1 = 0 ;
2836     int res1 = 0 ;
2837     char temp2[STRMAX] ;
2838     int res2 ;
2839     int argvi = 0;
2840     dXSARGS;
2841
2842     if ((items < 2) || (items > 2)) {
2843       SWIG_croak("Usage: Header_clntcompprog_set(self,clntcompprog);");
2844     }
2845     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2846     if (!SWIG_IsOK(res1)) {
2847       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clntcompprog_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2848     }
2849     arg1 = (dumpfile_t *)(argp1);
2850     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2851     if (!SWIG_IsOK(res2)) {
2852       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clntcompprog_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2853     }
2854     arg2 = (char *)(temp2);
2855     {
2856       strncpy(arg1->clntcompprog, arg2, STRMAX);
2857       if (arg1->clntcompprog[STRMAX-1] != '\0')
2858       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2859     }
2860     ST(argvi) = sv_newmortal();
2861
2862
2863     XSRETURN(argvi);
2864   fail:
2865
2866
2867     SWIG_croak_null();
2868   }
2869 }
2870
2871
2872 XS(_wrap_Header_clntcompprog_get) {
2873   {
2874     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2875     void *argp1 = 0 ;
2876     int res1 = 0 ;
2877     int argvi = 0;
2878     char *result = 0 ;
2879     dXSARGS;
2880
2881     if ((items < 1) || (items > 1)) {
2882       SWIG_croak("Usage: Header_clntcompprog_get(self);");
2883     }
2884     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2885     if (!SWIG_IsOK(res1)) {
2886       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clntcompprog_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2887     }
2888     arg1 = (dumpfile_t *)(argp1);
2889     result = (char *) ((arg1)->clntcompprog);
2890     {
2891       size_t size = STRMAX;
2892
2893       while (size && (result[size - 1] == '\0')) --size;
2894
2895       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2896     }
2897
2898     XSRETURN(argvi);
2899   fail:
2900
2901     SWIG_croak_null();
2902   }
2903 }
2904
2905
2906 XS(_wrap_Header_srv_encrypt_set) {
2907   {
2908     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2909     char *arg2 ;
2910     void *argp1 = 0 ;
2911     int res1 = 0 ;
2912     char temp2[STRMAX] ;
2913     int res2 ;
2914     int argvi = 0;
2915     dXSARGS;
2916
2917     if ((items < 2) || (items > 2)) {
2918       SWIG_croak("Usage: Header_srv_encrypt_set(self,srv_encrypt);");
2919     }
2920     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2921     if (!SWIG_IsOK(res1)) {
2922       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_encrypt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2923     }
2924     arg1 = (dumpfile_t *)(argp1);
2925     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2926     if (!SWIG_IsOK(res2)) {
2927       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srv_encrypt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2928     }
2929     arg2 = (char *)(temp2);
2930     {
2931       strncpy(arg1->srv_encrypt, arg2, STRMAX);
2932       if (arg1->srv_encrypt[STRMAX-1] != '\0')
2933       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2934     }
2935     ST(argvi) = sv_newmortal();
2936
2937
2938     XSRETURN(argvi);
2939   fail:
2940
2941
2942     SWIG_croak_null();
2943   }
2944 }
2945
2946
2947 XS(_wrap_Header_srv_encrypt_get) {
2948   {
2949     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2950     void *argp1 = 0 ;
2951     int res1 = 0 ;
2952     int argvi = 0;
2953     char *result = 0 ;
2954     dXSARGS;
2955
2956     if ((items < 1) || (items > 1)) {
2957       SWIG_croak("Usage: Header_srv_encrypt_get(self);");
2958     }
2959     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2960     if (!SWIG_IsOK(res1)) {
2961       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_encrypt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2962     }
2963     arg1 = (dumpfile_t *)(argp1);
2964     result = (char *) ((arg1)->srv_encrypt);
2965     {
2966       size_t size = STRMAX;
2967
2968       while (size && (result[size - 1] == '\0')) --size;
2969
2970       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2971     }
2972
2973     XSRETURN(argvi);
2974   fail:
2975
2976     SWIG_croak_null();
2977   }
2978 }
2979
2980
2981 XS(_wrap_Header_clnt_encrypt_set) {
2982   {
2983     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2984     char *arg2 ;
2985     void *argp1 = 0 ;
2986     int res1 = 0 ;
2987     char temp2[STRMAX] ;
2988     int res2 ;
2989     int argvi = 0;
2990     dXSARGS;
2991
2992     if ((items < 2) || (items > 2)) {
2993       SWIG_croak("Usage: Header_clnt_encrypt_set(self,clnt_encrypt);");
2994     }
2995     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2996     if (!SWIG_IsOK(res1)) {
2997       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_encrypt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2998     }
2999     arg1 = (dumpfile_t *)(argp1);
3000     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3001     if (!SWIG_IsOK(res2)) {
3002       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clnt_encrypt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3003     }
3004     arg2 = (char *)(temp2);
3005     {
3006       strncpy(arg1->clnt_encrypt, arg2, STRMAX);
3007       if (arg1->clnt_encrypt[STRMAX-1] != '\0')
3008       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3009     }
3010     ST(argvi) = sv_newmortal();
3011
3012
3013     XSRETURN(argvi);
3014   fail:
3015
3016
3017     SWIG_croak_null();
3018   }
3019 }
3020
3021
3022 XS(_wrap_Header_clnt_encrypt_get) {
3023   {
3024     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3025     void *argp1 = 0 ;
3026     int res1 = 0 ;
3027     int argvi = 0;
3028     char *result = 0 ;
3029     dXSARGS;
3030
3031     if ((items < 1) || (items > 1)) {
3032       SWIG_croak("Usage: Header_clnt_encrypt_get(self);");
3033     }
3034     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3035     if (!SWIG_IsOK(res1)) {
3036       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_encrypt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3037     }
3038     arg1 = (dumpfile_t *)(argp1);
3039     result = (char *) ((arg1)->clnt_encrypt);
3040     {
3041       size_t size = STRMAX;
3042
3043       while (size && (result[size - 1] == '\0')) --size;
3044
3045       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3046     }
3047
3048     XSRETURN(argvi);
3049   fail:
3050
3051     SWIG_croak_null();
3052   }
3053 }
3054
3055
3056 XS(_wrap_Header_recover_cmd_set) {
3057   {
3058     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3059     char *arg2 ;
3060     void *argp1 = 0 ;
3061     int res1 = 0 ;
3062     char temp2[STRMAX] ;
3063     int res2 ;
3064     int argvi = 0;
3065     dXSARGS;
3066
3067     if ((items < 2) || (items > 2)) {
3068       SWIG_croak("Usage: Header_recover_cmd_set(self,recover_cmd);");
3069     }
3070     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3071     if (!SWIG_IsOK(res1)) {
3072       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_recover_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3073     }
3074     arg1 = (dumpfile_t *)(argp1);
3075     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3076     if (!SWIG_IsOK(res2)) {
3077       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_recover_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3078     }
3079     arg2 = (char *)(temp2);
3080     {
3081       strncpy(arg1->recover_cmd, arg2, STRMAX);
3082       if (arg1->recover_cmd[STRMAX-1] != '\0')
3083       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3084     }
3085     ST(argvi) = sv_newmortal();
3086
3087
3088     XSRETURN(argvi);
3089   fail:
3090
3091
3092     SWIG_croak_null();
3093   }
3094 }
3095
3096
3097 XS(_wrap_Header_recover_cmd_get) {
3098   {
3099     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3100     void *argp1 = 0 ;
3101     int res1 = 0 ;
3102     int argvi = 0;
3103     char *result = 0 ;
3104     dXSARGS;
3105
3106     if ((items < 1) || (items > 1)) {
3107       SWIG_croak("Usage: Header_recover_cmd_get(self);");
3108     }
3109     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3110     if (!SWIG_IsOK(res1)) {
3111       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_recover_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3112     }
3113     arg1 = (dumpfile_t *)(argp1);
3114     result = (char *) ((arg1)->recover_cmd);
3115     {
3116       size_t size = STRMAX;
3117
3118       while (size && (result[size - 1] == '\0')) --size;
3119
3120       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3121     }
3122
3123     XSRETURN(argvi);
3124   fail:
3125
3126     SWIG_croak_null();
3127   }
3128 }
3129
3130
3131 XS(_wrap_Header_uncompress_cmd_set) {
3132   {
3133     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3134     char *arg2 ;
3135     void *argp1 = 0 ;
3136     int res1 = 0 ;
3137     char temp2[STRMAX] ;
3138     int res2 ;
3139     int argvi = 0;
3140     dXSARGS;
3141
3142     if ((items < 2) || (items > 2)) {
3143       SWIG_croak("Usage: Header_uncompress_cmd_set(self,uncompress_cmd);");
3144     }
3145     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3146     if (!SWIG_IsOK(res1)) {
3147       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_uncompress_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3148     }
3149     arg1 = (dumpfile_t *)(argp1);
3150     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3151     if (!SWIG_IsOK(res2)) {
3152       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_uncompress_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3153     }
3154     arg2 = (char *)(temp2);
3155     {
3156       strncpy(arg1->uncompress_cmd, arg2, STRMAX);
3157       if (arg1->uncompress_cmd[STRMAX-1] != '\0')
3158       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3159     }
3160     ST(argvi) = sv_newmortal();
3161
3162
3163     XSRETURN(argvi);
3164   fail:
3165
3166
3167     SWIG_croak_null();
3168   }
3169 }
3170
3171
3172 XS(_wrap_Header_uncompress_cmd_get) {
3173   {
3174     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3175     void *argp1 = 0 ;
3176     int res1 = 0 ;
3177     int argvi = 0;
3178     char *result = 0 ;
3179     dXSARGS;
3180
3181     if ((items < 1) || (items > 1)) {
3182       SWIG_croak("Usage: Header_uncompress_cmd_get(self);");
3183     }
3184     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3185     if (!SWIG_IsOK(res1)) {
3186       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_uncompress_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3187     }
3188     arg1 = (dumpfile_t *)(argp1);
3189     result = (char *) ((arg1)->uncompress_cmd);
3190     {
3191       size_t size = STRMAX;
3192
3193       while (size && (result[size - 1] == '\0')) --size;
3194
3195       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3196     }
3197
3198     XSRETURN(argvi);
3199   fail:
3200
3201     SWIG_croak_null();
3202   }
3203 }
3204
3205
3206 XS(_wrap_Header_decrypt_cmd_set) {
3207   {
3208     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3209     char *arg2 ;
3210     void *argp1 = 0 ;
3211     int res1 = 0 ;
3212     char temp2[STRMAX] ;
3213     int res2 ;
3214     int argvi = 0;
3215     dXSARGS;
3216
3217     if ((items < 2) || (items > 2)) {
3218       SWIG_croak("Usage: Header_decrypt_cmd_set(self,decrypt_cmd);");
3219     }
3220     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3221     if (!SWIG_IsOK(res1)) {
3222       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_decrypt_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3223     }
3224     arg1 = (dumpfile_t *)(argp1);
3225     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3226     if (!SWIG_IsOK(res2)) {
3227       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_decrypt_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3228     }
3229     arg2 = (char *)(temp2);
3230     {
3231       strncpy(arg1->decrypt_cmd, arg2, STRMAX);
3232       if (arg1->decrypt_cmd[STRMAX-1] != '\0')
3233       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3234     }
3235     ST(argvi) = sv_newmortal();
3236
3237
3238     XSRETURN(argvi);
3239   fail:
3240
3241
3242     SWIG_croak_null();
3243   }
3244 }
3245
3246
3247 XS(_wrap_Header_decrypt_cmd_get) {
3248   {
3249     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3250     void *argp1 = 0 ;
3251     int res1 = 0 ;
3252     int argvi = 0;
3253     char *result = 0 ;
3254     dXSARGS;
3255
3256     if ((items < 1) || (items > 1)) {
3257       SWIG_croak("Usage: Header_decrypt_cmd_get(self);");
3258     }
3259     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3260     if (!SWIG_IsOK(res1)) {
3261       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_decrypt_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3262     }
3263     arg1 = (dumpfile_t *)(argp1);
3264     result = (char *) ((arg1)->decrypt_cmd);
3265     {
3266       size_t size = STRMAX;
3267
3268       while (size && (result[size - 1] == '\0')) --size;
3269
3270       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3271     }
3272
3273     XSRETURN(argvi);
3274   fail:
3275
3276     SWIG_croak_null();
3277   }
3278 }
3279
3280
3281 XS(_wrap_Header_srv_decrypt_opt_set) {
3282   {
3283     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3284     char *arg2 ;
3285     void *argp1 = 0 ;
3286     int res1 = 0 ;
3287     char temp2[STRMAX] ;
3288     int res2 ;
3289     int argvi = 0;
3290     dXSARGS;
3291
3292     if ((items < 2) || (items > 2)) {
3293       SWIG_croak("Usage: Header_srv_decrypt_opt_set(self,srv_decrypt_opt);");
3294     }
3295     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3296     if (!SWIG_IsOK(res1)) {
3297       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_decrypt_opt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3298     }
3299     arg1 = (dumpfile_t *)(argp1);
3300     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3301     if (!SWIG_IsOK(res2)) {
3302       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srv_decrypt_opt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3303     }
3304     arg2 = (char *)(temp2);
3305     {
3306       strncpy(arg1->srv_decrypt_opt, arg2, STRMAX);
3307       if (arg1->srv_decrypt_opt[STRMAX-1] != '\0')
3308       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3309     }
3310     ST(argvi) = sv_newmortal();
3311
3312
3313     XSRETURN(argvi);
3314   fail:
3315
3316
3317     SWIG_croak_null();
3318   }
3319 }
3320
3321
3322 XS(_wrap_Header_srv_decrypt_opt_get) {
3323   {
3324     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3325     void *argp1 = 0 ;
3326     int res1 = 0 ;
3327     int argvi = 0;
3328     char *result = 0 ;
3329     dXSARGS;
3330
3331     if ((items < 1) || (items > 1)) {
3332       SWIG_croak("Usage: Header_srv_decrypt_opt_get(self);");
3333     }
3334     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3335     if (!SWIG_IsOK(res1)) {
3336       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_decrypt_opt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3337     }
3338     arg1 = (dumpfile_t *)(argp1);
3339     result = (char *) ((arg1)->srv_decrypt_opt);
3340     {
3341       size_t size = STRMAX;
3342
3343       while (size && (result[size - 1] == '\0')) --size;
3344
3345       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3346     }
3347
3348     XSRETURN(argvi);
3349   fail:
3350
3351     SWIG_croak_null();
3352   }
3353 }
3354
3355
3356 XS(_wrap_Header_clnt_decrypt_opt_set) {
3357   {
3358     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3359     char *arg2 ;
3360     void *argp1 = 0 ;
3361     int res1 = 0 ;
3362     char temp2[STRMAX] ;
3363     int res2 ;
3364     int argvi = 0;
3365     dXSARGS;
3366
3367     if ((items < 2) || (items > 2)) {
3368       SWIG_croak("Usage: Header_clnt_decrypt_opt_set(self,clnt_decrypt_opt);");
3369     }
3370     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3371     if (!SWIG_IsOK(res1)) {
3372       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_decrypt_opt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3373     }
3374     arg1 = (dumpfile_t *)(argp1);
3375     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3376     if (!SWIG_IsOK(res2)) {
3377       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clnt_decrypt_opt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3378     }
3379     arg2 = (char *)(temp2);
3380     {
3381       strncpy(arg1->clnt_decrypt_opt, arg2, STRMAX);
3382       if (arg1->clnt_decrypt_opt[STRMAX-1] != '\0')
3383       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3384     }
3385     ST(argvi) = sv_newmortal();
3386
3387
3388     XSRETURN(argvi);
3389   fail:
3390
3391
3392     SWIG_croak_null();
3393   }
3394 }
3395
3396
3397 XS(_wrap_Header_clnt_decrypt_opt_get) {
3398   {
3399     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3400     void *argp1 = 0 ;
3401     int res1 = 0 ;
3402     int argvi = 0;
3403     char *result = 0 ;
3404     dXSARGS;
3405
3406     if ((items < 1) || (items > 1)) {
3407       SWIG_croak("Usage: Header_clnt_decrypt_opt_get(self);");
3408     }
3409     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3410     if (!SWIG_IsOK(res1)) {
3411       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_decrypt_opt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3412     }
3413     arg1 = (dumpfile_t *)(argp1);
3414     result = (char *) ((arg1)->clnt_decrypt_opt);
3415     {
3416       size_t size = STRMAX;
3417
3418       while (size && (result[size - 1] == '\0')) --size;
3419
3420       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3421     }
3422
3423     XSRETURN(argvi);
3424   fail:
3425
3426     SWIG_croak_null();
3427   }
3428 }
3429
3430
3431 XS(_wrap_Header_cont_filename_set) {
3432   {
3433     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3434     char *arg2 ;
3435     void *argp1 = 0 ;
3436     int res1 = 0 ;
3437     char temp2[STRMAX] ;
3438     int res2 ;
3439     int argvi = 0;
3440     dXSARGS;
3441
3442     if ((items < 2) || (items > 2)) {
3443       SWIG_croak("Usage: Header_cont_filename_set(self,cont_filename);");
3444     }
3445     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3446     if (!SWIG_IsOK(res1)) {
3447       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_cont_filename_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3448     }
3449     arg1 = (dumpfile_t *)(argp1);
3450     res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3451     if (!SWIG_IsOK(res2)) {
3452       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_cont_filename_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3453     }
3454     arg2 = (char *)(temp2);
3455     {
3456       strncpy(arg1->cont_filename, arg2, STRMAX);
3457       if (arg1->cont_filename[STRMAX-1] != '\0')
3458       SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3459     }
3460     ST(argvi) = sv_newmortal();
3461
3462
3463     XSRETURN(argvi);
3464   fail:
3465
3466
3467     SWIG_croak_null();
3468   }
3469 }
3470
3471
3472 XS(_wrap_Header_cont_filename_get) {
3473   {
3474     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3475     void *argp1 = 0 ;
3476     int res1 = 0 ;
3477     int argvi = 0;
3478     char *result = 0 ;
3479     dXSARGS;
3480
3481     if ((items < 1) || (items > 1)) {
3482       SWIG_croak("Usage: Header_cont_filename_get(self);");
3483     }
3484     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3485     if (!SWIG_IsOK(res1)) {
3486       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_cont_filename_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3487     }
3488     arg1 = (dumpfile_t *)(argp1);
3489     result = (char *) ((arg1)->cont_filename);
3490     {
3491       size_t size = STRMAX;
3492
3493       while (size && (result[size - 1] == '\0')) --size;
3494
3495       ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3496     }
3497
3498     XSRETURN(argvi);
3499   fail:
3500
3501     SWIG_croak_null();
3502   }
3503 }
3504
3505
3506 XS(_wrap_Header_dle_str_set) {
3507   {
3508     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3509     char *arg2 = (char *) 0 ;
3510     void *argp1 = 0 ;
3511     int res1 = 0 ;
3512     int res2 ;
3513     char *buf2 = 0 ;
3514     int alloc2 = 0 ;
3515     int argvi = 0;
3516     dXSARGS;
3517
3518     if ((items < 2) || (items > 2)) {
3519       SWIG_croak("Usage: Header_dle_str_set(self,dle_str);");
3520     }
3521     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3522     if (!SWIG_IsOK(res1)) {
3523       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dle_str_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3524     }
3525     arg1 = (dumpfile_t *)(argp1);
3526     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3527     if (!SWIG_IsOK(res2)) {
3528       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_dle_str_set" "', argument " "2"" of type '" "char *""'");
3529     }
3530     arg2 = (char *)(buf2);
3531     if (arg1->dle_str) free((char*)arg1->dle_str);
3532     if (arg2) {
3533       size_t size = strlen((const char *)(arg2)) + 1;
3534       arg1->dle_str = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
3535     } else {
3536       arg1->dle_str = 0;
3537     }
3538     ST(argvi) = sv_newmortal();
3539
3540     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3541     XSRETURN(argvi);
3542   fail:
3543
3544     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3545     SWIG_croak_null();
3546   }
3547 }
3548
3549
3550 XS(_wrap_Header_dle_str_get) {
3551   {
3552     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3553     void *argp1 = 0 ;
3554     int res1 = 0 ;
3555     int argvi = 0;
3556     char *result = 0 ;
3557     dXSARGS;
3558
3559     if ((items < 1) || (items > 1)) {
3560       SWIG_croak("Usage: Header_dle_str_get(self);");
3561     }
3562     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3563     if (!SWIG_IsOK(res1)) {
3564       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dle_str_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3565     }
3566     arg1 = (dumpfile_t *)(argp1);
3567     result = (char *) ((arg1)->dle_str);
3568     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3569
3570     XSRETURN(argvi);
3571   fail:
3572
3573     SWIG_croak_null();
3574   }
3575 }
3576
3577
3578 XS(_wrap_Header_is_partial_set) {
3579   {
3580     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3581     int arg2 ;
3582     void *argp1 = 0 ;
3583     int res1 = 0 ;
3584     int argvi = 0;
3585     dXSARGS;
3586
3587     if ((items < 2) || (items > 2)) {
3588       SWIG_croak("Usage: Header_is_partial_set(self,is_partial);");
3589     }
3590     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3591     if (!SWIG_IsOK(res1)) {
3592       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_is_partial_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3593     }
3594     arg1 = (dumpfile_t *)(argp1);
3595     {
3596       if (sizeof(signed int) == 1) {
3597         arg2 = amglue_SvI8(ST(1));
3598       } else if (sizeof(signed int) == 2) {
3599         arg2 = amglue_SvI16(ST(1));
3600       } else if (sizeof(signed int) == 4) {
3601         arg2 = amglue_SvI32(ST(1));
3602       } else if (sizeof(signed int) == 8) {
3603         arg2 = amglue_SvI64(ST(1));
3604       } else {
3605         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3606       }
3607     }
3608     if (arg1) (arg1)->is_partial = arg2;
3609     ST(argvi) = sv_newmortal();
3610
3611
3612     XSRETURN(argvi);
3613   fail:
3614
3615
3616     SWIG_croak_null();
3617   }
3618 }
3619
3620
3621 XS(_wrap_Header_is_partial_get) {
3622   {
3623     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3624     void *argp1 = 0 ;
3625     int res1 = 0 ;
3626     int argvi = 0;
3627     int result;
3628     dXSARGS;
3629
3630     if ((items < 1) || (items > 1)) {
3631       SWIG_croak("Usage: Header_is_partial_get(self);");
3632     }
3633     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3634     if (!SWIG_IsOK(res1)) {
3635       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_is_partial_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3636     }
3637     arg1 = (dumpfile_t *)(argp1);
3638     result = (int) ((arg1)->is_partial);
3639     {
3640       SV *for_stack;
3641       SP += argvi; PUTBACK;
3642       for_stack = sv_2mortal(amglue_newSVi64(result));
3643       SPAGAIN; SP -= argvi;
3644       ST(argvi) = for_stack;
3645       argvi++;
3646     }
3647
3648     XSRETURN(argvi);
3649   fail:
3650
3651     SWIG_croak_null();
3652   }
3653 }
3654
3655
3656 XS(_wrap_Header_partnum_set) {
3657   {
3658     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3659     int arg2 ;
3660     void *argp1 = 0 ;
3661     int res1 = 0 ;
3662     int argvi = 0;
3663     dXSARGS;
3664
3665     if ((items < 2) || (items > 2)) {
3666       SWIG_croak("Usage: Header_partnum_set(self,partnum);");
3667     }
3668     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3669     if (!SWIG_IsOK(res1)) {
3670       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_partnum_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3671     }
3672     arg1 = (dumpfile_t *)(argp1);
3673     {
3674       if (sizeof(signed int) == 1) {
3675         arg2 = amglue_SvI8(ST(1));
3676       } else if (sizeof(signed int) == 2) {
3677         arg2 = amglue_SvI16(ST(1));
3678       } else if (sizeof(signed int) == 4) {
3679         arg2 = amglue_SvI32(ST(1));
3680       } else if (sizeof(signed int) == 8) {
3681         arg2 = amglue_SvI64(ST(1));
3682       } else {
3683         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3684       }
3685     }
3686     if (arg1) (arg1)->partnum = arg2;
3687     ST(argvi) = sv_newmortal();
3688
3689
3690     XSRETURN(argvi);
3691   fail:
3692
3693
3694     SWIG_croak_null();
3695   }
3696 }
3697
3698
3699 XS(_wrap_Header_partnum_get) {
3700   {
3701     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3702     void *argp1 = 0 ;
3703     int res1 = 0 ;
3704     int argvi = 0;
3705     int result;
3706     dXSARGS;
3707
3708     if ((items < 1) || (items > 1)) {
3709       SWIG_croak("Usage: Header_partnum_get(self);");
3710     }
3711     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3712     if (!SWIG_IsOK(res1)) {
3713       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_partnum_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3714     }
3715     arg1 = (dumpfile_t *)(argp1);
3716     result = (int) ((arg1)->partnum);
3717     {
3718       SV *for_stack;
3719       SP += argvi; PUTBACK;
3720       for_stack = sv_2mortal(amglue_newSVi64(result));
3721       SPAGAIN; SP -= argvi;
3722       ST(argvi) = for_stack;
3723       argvi++;
3724     }
3725
3726     XSRETURN(argvi);
3727   fail:
3728
3729     SWIG_croak_null();
3730   }
3731 }
3732
3733
3734 XS(_wrap_Header_totalparts_set) {
3735   {
3736     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3737     int arg2 ;
3738     void *argp1 = 0 ;
3739     int res1 = 0 ;
3740     int argvi = 0;
3741     dXSARGS;
3742
3743     if ((items < 2) || (items > 2)) {
3744       SWIG_croak("Usage: Header_totalparts_set(self,totalparts);");
3745     }
3746     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3747     if (!SWIG_IsOK(res1)) {
3748       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_totalparts_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3749     }
3750     arg1 = (dumpfile_t *)(argp1);
3751     {
3752       if (sizeof(signed int) == 1) {
3753         arg2 = amglue_SvI8(ST(1));
3754       } else if (sizeof(signed int) == 2) {
3755         arg2 = amglue_SvI16(ST(1));
3756       } else if (sizeof(signed int) == 4) {
3757         arg2 = amglue_SvI32(ST(1));
3758       } else if (sizeof(signed int) == 8) {
3759         arg2 = amglue_SvI64(ST(1));
3760       } else {
3761         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3762       }
3763     }
3764     if (arg1) (arg1)->totalparts = arg2;
3765     ST(argvi) = sv_newmortal();
3766
3767
3768     XSRETURN(argvi);
3769   fail:
3770
3771
3772     SWIG_croak_null();
3773   }
3774 }
3775
3776
3777 XS(_wrap_Header_totalparts_get) {
3778   {
3779     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3780     void *argp1 = 0 ;
3781     int res1 = 0 ;
3782     int argvi = 0;
3783     int result;
3784     dXSARGS;
3785
3786     if ((items < 1) || (items > 1)) {
3787       SWIG_croak("Usage: Header_totalparts_get(self);");
3788     }
3789     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3790     if (!SWIG_IsOK(res1)) {
3791       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_totalparts_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3792     }
3793     arg1 = (dumpfile_t *)(argp1);
3794     result = (int) ((arg1)->totalparts);
3795     {
3796       SV *for_stack;
3797       SP += argvi; PUTBACK;
3798       for_stack = sv_2mortal(amglue_newSVi64(result));
3799       SPAGAIN; SP -= argvi;
3800       ST(argvi) = for_stack;
3801       argvi++;
3802     }
3803
3804     XSRETURN(argvi);
3805   fail:
3806
3807     SWIG_croak_null();
3808   }
3809 }
3810
3811
3812 XS(_wrap_Header_blocksize_set) {
3813   {
3814     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3815     size_t arg2 ;
3816     void *argp1 = 0 ;
3817     int res1 = 0 ;
3818     int argvi = 0;
3819     dXSARGS;
3820
3821     if ((items < 2) || (items > 2)) {
3822       SWIG_croak("Usage: Header_blocksize_set(self,blocksize);");
3823     }
3824     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3825     if (!SWIG_IsOK(res1)) {
3826       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_blocksize_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3827     }
3828     arg1 = (dumpfile_t *)(argp1);
3829     {
3830       if (sizeof(size_t) == 1) {
3831         arg2 = amglue_SvU8(ST(1));
3832       } else if (sizeof(size_t) == 2) {
3833         arg2 = amglue_SvU16(ST(1));
3834       } else if (sizeof(size_t) == 4) {
3835         arg2 = amglue_SvU32(ST(1));
3836       } else if (sizeof(size_t) == 8) {
3837         arg2 = amglue_SvU64(ST(1));
3838       } else {
3839         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
3840       }
3841     }
3842     if (arg1) (arg1)->blocksize = arg2;
3843     ST(argvi) = sv_newmortal();
3844
3845
3846     XSRETURN(argvi);
3847   fail:
3848
3849
3850     SWIG_croak_null();
3851   }
3852 }
3853
3854
3855 XS(_wrap_Header_blocksize_get) {
3856   {
3857     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3858     void *argp1 = 0 ;
3859     int res1 = 0 ;
3860     int argvi = 0;
3861     size_t result;
3862     dXSARGS;
3863
3864     if ((items < 1) || (items > 1)) {
3865       SWIG_croak("Usage: Header_blocksize_get(self);");
3866     }
3867     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3868     if (!SWIG_IsOK(res1)) {
3869       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_blocksize_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3870     }
3871     arg1 = (dumpfile_t *)(argp1);
3872     result =  ((arg1)->blocksize);
3873     {
3874       SV *for_stack;
3875       SP += argvi; PUTBACK;
3876       for_stack = sv_2mortal(amglue_newSVu64(result));
3877       SPAGAIN; SP -= argvi;
3878       ST(argvi) = for_stack;
3879       argvi++;
3880     }
3881
3882     XSRETURN(argvi);
3883   fail:
3884
3885     SWIG_croak_null();
3886   }
3887 }
3888
3889
3890 XS(_wrap_Header_orig_size_set) {
3891   {
3892     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3893     off_t arg2 ;
3894     void *argp1 = 0 ;
3895     int res1 = 0 ;
3896     int argvi = 0;
3897     dXSARGS;
3898
3899     if ((items < 2) || (items > 2)) {
3900       SWIG_croak("Usage: Header_orig_size_set(self,orig_size);");
3901     }
3902     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3903     if (!SWIG_IsOK(res1)) {
3904       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_orig_size_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3905     }
3906     arg1 = (dumpfile_t *)(argp1);
3907     {
3908       if (sizeof(off_t) == 1) {
3909         arg2 = amglue_SvU8(ST(1));
3910       } else if (sizeof(off_t) == 2) {
3911         arg2 = amglue_SvU16(ST(1));
3912       } else if (sizeof(off_t) == 4) {
3913         arg2 = amglue_SvU32(ST(1));
3914       } else if (sizeof(off_t) == 8) {
3915         arg2 = amglue_SvU64(ST(1));
3916       } else {
3917         croak("Unexpected off_t >64 bits?"); /* should be optimized out unless sizeof(off_t) > 8 */
3918       }
3919     }
3920     if (arg1) (arg1)->orig_size = arg2;
3921     ST(argvi) = sv_newmortal();
3922
3923     XSRETURN(argvi);
3924   fail:
3925
3926     SWIG_croak_null();
3927   }
3928 }
3929
3930
3931 XS(_wrap_Header_orig_size_get) {
3932   {
3933     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3934     void *argp1 = 0 ;
3935     int res1 = 0 ;
3936     int argvi = 0;
3937     off_t result;
3938     dXSARGS;
3939
3940     if ((items < 1) || (items > 1)) {
3941       SWIG_croak("Usage: Header_orig_size_get(self);");
3942     }
3943     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3944     if (!SWIG_IsOK(res1)) {
3945       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_orig_size_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3946     }
3947     arg1 = (dumpfile_t *)(argp1);
3948     result =  ((arg1)->orig_size);
3949     {
3950       SV *for_stack;
3951       SP += argvi; PUTBACK;
3952       for_stack = sv_2mortal(amglue_newSVu64(result));
3953       SPAGAIN; SP -= argvi;
3954       ST(argvi) = for_stack;
3955       argvi++;
3956     }
3957
3958     XSRETURN(argvi);
3959   fail:
3960
3961     SWIG_croak_null();
3962   }
3963 }
3964
3965
3966 XS(_wrap_new_Header) {
3967   {
3968     int argvi = 0;
3969     dumpfile_t *result = 0 ;
3970     dXSARGS;
3971
3972     if ((items < 0) || (items > 0)) {
3973       SWIG_croak("Usage: new_Header();");
3974     }
3975     result = (dumpfile_t *)new_dumpfile_t();
3976     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3977     XSRETURN(argvi);
3978   fail:
3979     SWIG_croak_null();
3980   }
3981 }
3982
3983
3984 XS(_wrap_Header_to_string) {
3985   {
3986     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3987     size_t arg2 ;
3988     size_t arg3 ;
3989     void *argp1 = 0 ;
3990     int res1 = 0 ;
3991     int argvi = 0;
3992     SV *result = 0 ;
3993     dXSARGS;
3994
3995     if ((items < 3) || (items > 3)) {
3996       SWIG_croak("Usage: Header_to_string(self,min_size,max_size);");
3997     }
3998     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
3999     if (!SWIG_IsOK(res1)) {
4000       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_to_string" "', argument " "1"" of type '" "dumpfile_t *""'");
4001     }
4002     arg1 = (dumpfile_t *)(argp1);
4003     {
4004       if (sizeof(size_t) == 1) {
4005         arg2 = amglue_SvU8(ST(1));
4006       } else if (sizeof(size_t) == 2) {
4007         arg2 = amglue_SvU16(ST(1));
4008       } else if (sizeof(size_t) == 4) {
4009         arg2 = amglue_SvU32(ST(1));
4010       } else if (sizeof(size_t) == 8) {
4011         arg2 = amglue_SvU64(ST(1));
4012       } else {
4013         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
4014       }
4015     }
4016     {
4017       if (sizeof(size_t) == 1) {
4018         arg3 = amglue_SvU8(ST(2));
4019       } else if (sizeof(size_t) == 2) {
4020         arg3 = amglue_SvU16(ST(2));
4021       } else if (sizeof(size_t) == 4) {
4022         arg3 = amglue_SvU32(ST(2));
4023       } else if (sizeof(size_t) == 8) {
4024         arg3 = amglue_SvU64(ST(2));
4025       } else {
4026         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
4027       }
4028     }
4029     result = (SV *)dumpfile_t_to_string(arg1,arg2,arg3);
4030     ST(argvi) = result; argvi++;
4031
4032
4033
4034     XSRETURN(argvi);
4035   fail:
4036
4037
4038
4039     SWIG_croak_null();
4040   }
4041 }
4042
4043
4044 XS(_wrap_Header_debug_dump) {
4045   {
4046     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4047     void *argp1 = 0 ;
4048     int res1 = 0 ;
4049     int argvi = 0;
4050     dXSARGS;
4051
4052     if ((items < 1) || (items > 1)) {
4053       SWIG_croak("Usage: Header_debug_dump(self);");
4054     }
4055     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
4056     if (!SWIG_IsOK(res1)) {
4057       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_debug_dump" "', argument " "1"" of type '" "dumpfile_t *""'");
4058     }
4059     arg1 = (dumpfile_t *)(argp1);
4060     dumpfile_t_debug_dump(arg1);
4061     ST(argvi) = sv_newmortal();
4062
4063     XSRETURN(argvi);
4064   fail:
4065
4066     SWIG_croak_null();
4067   }
4068 }
4069
4070
4071 XS(_wrap_Header_summary) {
4072   {
4073     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4074     void *argp1 = 0 ;
4075     int res1 = 0 ;
4076     int argvi = 0;
4077     char *result = 0 ;
4078     dXSARGS;
4079
4080     if ((items < 1) || (items > 1)) {
4081       SWIG_croak("Usage: Header_summary(self);");
4082     }
4083     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 |  0 );
4084     if (!SWIG_IsOK(res1)) {
4085       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_summary" "', argument " "1"" of type '" "dumpfile_t *""'");
4086     }
4087     arg1 = (dumpfile_t *)(argp1);
4088     result = (char *)dumpfile_t_summary(arg1);
4089     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4090
4091     free((char*)result);
4092     XSRETURN(argvi);
4093   fail:
4094
4095     SWIG_croak_null();
4096   }
4097 }
4098
4099
4100 XS(_wrap_delete_Header__SWIG_1) {
4101   {
4102     dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4103     void *argp1 = 0 ;
4104     int res1 = 0 ;
4105     int argvi = 0;
4106     dXSARGS;
4107
4108     if ((items < 1) || (items > 1)) {
4109       SWIG_croak("Usage: delete_Header(self);");
4110     }
4111     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, SWIG_POINTER_DISOWN |  0 );
4112     if (!SWIG_IsOK(res1)) {
4113       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Header" "', argument " "1"" of type '" "dumpfile_t *""'");
4114     }
4115     arg1 = (dumpfile_t *)(argp1);
4116     free((char *) arg1);
4117     ST(argvi) = sv_newmortal();
4118
4119     XSRETURN(argvi);
4120   fail:
4121
4122     SWIG_croak_null();
4123   }
4124 }
4125
4126
4127 XS(_wrap_delete_Header) {
4128   dXSARGS;
4129
4130   {
4131     unsigned long _index = 0;
4132     SWIG_TypeRank _rank = 0;
4133     if (items == 1) {
4134       SWIG_TypeRank _ranki = 0;
4135       SWIG_TypeRank _rankm = 0;
4136       SWIG_TypeRank _pi = 1;
4137       int _v = 0;
4138       {
4139         void *vptr = 0;
4140         int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_dumpfile_t, 0);
4141         _v = SWIG_CheckState(res);
4142       }
4143       if (!_v) goto check_1;
4144       _ranki += _v*_pi;
4145       _rankm += _pi;
4146       _pi *= SWIG_MAXCASTRANK;
4147       if (!_index || (_ranki < _rank)) {
4148         _rank = _ranki; _index = 1;
4149         if (_rank == _rankm) goto dispatch;
4150       }
4151     }
4152   check_1:
4153
4154   dispatch:
4155     switch(_index) {
4156     case 1:
4157       ++PL_markstack_ptr; SWIG_CALLXS(_wrap_delete_Header__SWIG_1); return;
4158     }
4159   }
4160
4161   croak("No matching function for overloaded 'delete_Header'");
4162   XSRETURN(0);
4163 }
4164
4165
4166 XS(_wrap_C_from_string) {
4167   {
4168     char *arg1 = (char *) 0 ;
4169     int res1 ;
4170     char *buf1 = 0 ;
4171     int alloc1 = 0 ;
4172     int argvi = 0;
4173     dumpfile_t *result = 0 ;
4174     dXSARGS;
4175
4176     if ((items < 1) || (items > 1)) {
4177       SWIG_croak("Usage: C_from_string(string);");
4178     }
4179     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
4180     if (!SWIG_IsOK(res1)) {
4181       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "C_from_string" "', argument " "1"" of type '" "char const *""'");
4182     }
4183     arg1 = (char *)(buf1);
4184     result = (dumpfile_t *)C_from_string((char const *)arg1);
4185     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
4186     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4187     XSRETURN(argvi);
4188   fail:
4189     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4190     SWIG_croak_null();
4191   }
4192 }
4193
4194
4195 XS(_wrap_HeaderXML_disk_set) {
4196   {
4197     dle_t *arg1 = (dle_t *) 0 ;
4198     char *arg2 = (char *) 0 ;
4199     void *argp1 = 0 ;
4200     int res1 = 0 ;
4201     int res2 ;
4202     char *buf2 = 0 ;
4203     int alloc2 = 0 ;
4204     int argvi = 0;
4205     dXSARGS;
4206
4207     if ((items < 2) || (items > 2)) {
4208       SWIG_croak("Usage: HeaderXML_disk_set(self,disk);");
4209     }
4210     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4211     if (!SWIG_IsOK(res1)) {
4212       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_disk_set" "', argument " "1"" of type '" "dle_t *""'");
4213     }
4214     arg1 = (dle_t *)(argp1);
4215     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
4216     if (!SWIG_IsOK(res2)) {
4217       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_disk_set" "', argument " "2"" of type '" "char *""'");
4218     }
4219     arg2 = (char *)(buf2);
4220     if (arg1->disk) free((char*)arg1->disk);
4221     if (arg2) {
4222       size_t size = strlen((const char *)(arg2)) + 1;
4223       arg1->disk = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4224     } else {
4225       arg1->disk = 0;
4226     }
4227     ST(argvi) = sv_newmortal();
4228
4229     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4230     XSRETURN(argvi);
4231   fail:
4232
4233     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4234     SWIG_croak_null();
4235   }
4236 }
4237
4238
4239 XS(_wrap_HeaderXML_disk_get) {
4240   {
4241     dle_t *arg1 = (dle_t *) 0 ;
4242     void *argp1 = 0 ;
4243     int res1 = 0 ;
4244     int argvi = 0;
4245     char *result = 0 ;
4246     dXSARGS;
4247
4248     if ((items < 1) || (items > 1)) {
4249       SWIG_croak("Usage: HeaderXML_disk_get(self);");
4250     }
4251     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4252     if (!SWIG_IsOK(res1)) {
4253       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_disk_get" "', argument " "1"" of type '" "dle_t *""'");
4254     }
4255     arg1 = (dle_t *)(argp1);
4256     result = (char *) ((arg1)->disk);
4257     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4258
4259     XSRETURN(argvi);
4260   fail:
4261
4262     SWIG_croak_null();
4263   }
4264 }
4265
4266
4267 XS(_wrap_HeaderXML_device_set) {
4268   {
4269     dle_t *arg1 = (dle_t *) 0 ;
4270     char *arg2 = (char *) 0 ;
4271     void *argp1 = 0 ;
4272     int res1 = 0 ;
4273     int res2 ;
4274     char *buf2 = 0 ;
4275     int alloc2 = 0 ;
4276     int argvi = 0;
4277     dXSARGS;
4278
4279     if ((items < 2) || (items > 2)) {
4280       SWIG_croak("Usage: HeaderXML_device_set(self,device);");
4281     }
4282     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4283     if (!SWIG_IsOK(res1)) {
4284       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_device_set" "', argument " "1"" of type '" "dle_t *""'");
4285     }
4286     arg1 = (dle_t *)(argp1);
4287     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
4288     if (!SWIG_IsOK(res2)) {
4289       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_device_set" "', argument " "2"" of type '" "char *""'");
4290     }
4291     arg2 = (char *)(buf2);
4292     if (arg1->device) free((char*)arg1->device);
4293     if (arg2) {
4294       size_t size = strlen((const char *)(arg2)) + 1;
4295       arg1->device = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4296     } else {
4297       arg1->device = 0;
4298     }
4299     ST(argvi) = sv_newmortal();
4300
4301     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4302     XSRETURN(argvi);
4303   fail:
4304
4305     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4306     SWIG_croak_null();
4307   }
4308 }
4309
4310
4311 XS(_wrap_HeaderXML_device_get) {
4312   {
4313     dle_t *arg1 = (dle_t *) 0 ;
4314     void *argp1 = 0 ;
4315     int res1 = 0 ;
4316     int argvi = 0;
4317     char *result = 0 ;
4318     dXSARGS;
4319
4320     if ((items < 1) || (items > 1)) {
4321       SWIG_croak("Usage: HeaderXML_device_get(self);");
4322     }
4323     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4324     if (!SWIG_IsOK(res1)) {
4325       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_device_get" "', argument " "1"" of type '" "dle_t *""'");
4326     }
4327     arg1 = (dle_t *)(argp1);
4328     result = (char *) ((arg1)->device);
4329     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4330
4331     XSRETURN(argvi);
4332   fail:
4333
4334     SWIG_croak_null();
4335   }
4336 }
4337
4338
4339 XS(_wrap_HeaderXML_program_is_application_api_set) {
4340   {
4341     dle_t *arg1 = (dle_t *) 0 ;
4342     int arg2 ;
4343     void *argp1 = 0 ;
4344     int res1 = 0 ;
4345     int argvi = 0;
4346     dXSARGS;
4347
4348     if ((items < 2) || (items > 2)) {
4349       SWIG_croak("Usage: HeaderXML_program_is_application_api_set(self,program_is_application_api);");
4350     }
4351     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4352     if (!SWIG_IsOK(res1)) {
4353       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_program_is_application_api_set" "', argument " "1"" of type '" "dle_t *""'");
4354     }
4355     arg1 = (dle_t *)(argp1);
4356     {
4357       if (sizeof(signed int) == 1) {
4358         arg2 = amglue_SvI8(ST(1));
4359       } else if (sizeof(signed int) == 2) {
4360         arg2 = amglue_SvI16(ST(1));
4361       } else if (sizeof(signed int) == 4) {
4362         arg2 = amglue_SvI32(ST(1));
4363       } else if (sizeof(signed int) == 8) {
4364         arg2 = amglue_SvI64(ST(1));
4365       } else {
4366         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4367       }
4368     }
4369     if (arg1) (arg1)->program_is_application_api = arg2;
4370     ST(argvi) = sv_newmortal();
4371
4372
4373     XSRETURN(argvi);
4374   fail:
4375
4376
4377     SWIG_croak_null();
4378   }
4379 }
4380
4381
4382 XS(_wrap_HeaderXML_program_is_application_api_get) {
4383   {
4384     dle_t *arg1 = (dle_t *) 0 ;
4385     void *argp1 = 0 ;
4386     int res1 = 0 ;
4387     int argvi = 0;
4388     int result;
4389     dXSARGS;
4390
4391     if ((items < 1) || (items > 1)) {
4392       SWIG_croak("Usage: HeaderXML_program_is_application_api_get(self);");
4393     }
4394     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4395     if (!SWIG_IsOK(res1)) {
4396       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_program_is_application_api_get" "', argument " "1"" of type '" "dle_t *""'");
4397     }
4398     arg1 = (dle_t *)(argp1);
4399     result = (int) ((arg1)->program_is_application_api);
4400     {
4401       SV *for_stack;
4402       SP += argvi; PUTBACK;
4403       for_stack = sv_2mortal(amglue_newSVi64(result));
4404       SPAGAIN; SP -= argvi;
4405       ST(argvi) = for_stack;
4406       argvi++;
4407     }
4408
4409     XSRETURN(argvi);
4410   fail:
4411
4412     SWIG_croak_null();
4413   }
4414 }
4415
4416
4417 XS(_wrap_HeaderXML_program_set) {
4418   {
4419     dle_t *arg1 = (dle_t *) 0 ;
4420     char *arg2 = (char *) 0 ;
4421     void *argp1 = 0 ;
4422     int res1 = 0 ;
4423     int res2 ;
4424     char *buf2 = 0 ;
4425     int alloc2 = 0 ;
4426     int argvi = 0;
4427     dXSARGS;
4428
4429     if ((items < 2) || (items > 2)) {
4430       SWIG_croak("Usage: HeaderXML_program_set(self,program);");
4431     }
4432     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4433     if (!SWIG_IsOK(res1)) {
4434       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_program_set" "', argument " "1"" of type '" "dle_t *""'");
4435     }
4436     arg1 = (dle_t *)(argp1);
4437     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
4438     if (!SWIG_IsOK(res2)) {
4439       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_program_set" "', argument " "2"" of type '" "char *""'");
4440     }
4441     arg2 = (char *)(buf2);
4442     if (arg1->program) free((char*)arg1->program);
4443     if (arg2) {
4444       size_t size = strlen((const char *)(arg2)) + 1;
4445       arg1->program = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4446     } else {
4447       arg1->program = 0;
4448     }
4449     ST(argvi) = sv_newmortal();
4450
4451     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4452     XSRETURN(argvi);
4453   fail:
4454
4455     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4456     SWIG_croak_null();
4457   }
4458 }
4459
4460
4461 XS(_wrap_HeaderXML_program_get) {
4462   {
4463     dle_t *arg1 = (dle_t *) 0 ;
4464     void *argp1 = 0 ;
4465     int res1 = 0 ;
4466     int argvi = 0;
4467     char *result = 0 ;
4468     dXSARGS;
4469
4470     if ((items < 1) || (items > 1)) {
4471       SWIG_croak("Usage: HeaderXML_program_get(self);");
4472     }
4473     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4474     if (!SWIG_IsOK(res1)) {
4475       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_program_get" "', argument " "1"" of type '" "dle_t *""'");
4476     }
4477     arg1 = (dle_t *)(argp1);
4478     result = (char *) ((arg1)->program);
4479     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4480
4481     XSRETURN(argvi);
4482   fail:
4483
4484     SWIG_croak_null();
4485   }
4486 }
4487
4488
4489 XS(_wrap_HeaderXML_estimatelist_set) {
4490   {
4491     dle_t *arg1 = (dle_t *) 0 ;
4492     estimatelist_t arg2 ;
4493     void *argp1 = 0 ;
4494     int res1 = 0 ;
4495     void *argp2 ;
4496     int res2 = 0 ;
4497     int argvi = 0;
4498     dXSARGS;
4499
4500     if ((items < 2) || (items > 2)) {
4501       SWIG_croak("Usage: HeaderXML_estimatelist_set(self,estimatelist);");
4502     }
4503     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4504     if (!SWIG_IsOK(res1)) {
4505       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_estimatelist_set" "', argument " "1"" of type '" "dle_t *""'");
4506     }
4507     arg1 = (dle_t *)(argp1);
4508     {
4509       res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_estimatelist_t,  0 );
4510       if (!SWIG_IsOK(res2)) {
4511         SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_estimatelist_set" "', argument " "2"" of type '" "estimatelist_t""'");
4512       }
4513       if (!argp2) {
4514         SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeaderXML_estimatelist_set" "', argument " "2"" of type '" "estimatelist_t""'");
4515       } else {
4516         arg2 = *((estimatelist_t *)(argp2));
4517       }
4518     }
4519     if (arg1) (arg1)->estimatelist = arg2;
4520     ST(argvi) = sv_newmortal();
4521
4522     XSRETURN(argvi);
4523   fail:
4524
4525     SWIG_croak_null();
4526   }
4527 }
4528
4529
4530 XS(_wrap_HeaderXML_estimatelist_get) {
4531   {
4532     dle_t *arg1 = (dle_t *) 0 ;
4533     void *argp1 = 0 ;
4534     int res1 = 0 ;
4535     int argvi = 0;
4536     estimatelist_t result;
4537     dXSARGS;
4538
4539     if ((items < 1) || (items > 1)) {
4540       SWIG_croak("Usage: HeaderXML_estimatelist_get(self);");
4541     }
4542     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4543     if (!SWIG_IsOK(res1)) {
4544       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_estimatelist_get" "', argument " "1"" of type '" "dle_t *""'");
4545     }
4546     arg1 = (dle_t *)(argp1);
4547     result =  ((arg1)->estimatelist);
4548     ST(argvi) = SWIG_NewPointerObj((estimatelist_t *)memcpy((estimatelist_t *)malloc(sizeof(estimatelist_t)),&result,sizeof(estimatelist_t)), SWIGTYPE_p_estimatelist_t, SWIG_POINTER_OWN | 0); argvi++ ;
4549
4550     XSRETURN(argvi);
4551   fail:
4552
4553     SWIG_croak_null();
4554   }
4555 }
4556
4557
4558 XS(_wrap_HeaderXML_spindle_set) {
4559   {
4560     dle_t *arg1 = (dle_t *) 0 ;
4561     int arg2 ;
4562     void *argp1 = 0 ;
4563     int res1 = 0 ;
4564     int argvi = 0;
4565     dXSARGS;
4566
4567     if ((items < 2) || (items > 2)) {
4568       SWIG_croak("Usage: HeaderXML_spindle_set(self,spindle);");
4569     }
4570     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4571     if (!SWIG_IsOK(res1)) {
4572       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_spindle_set" "', argument " "1"" of type '" "dle_t *""'");
4573     }
4574     arg1 = (dle_t *)(argp1);
4575     {
4576       if (sizeof(signed int) == 1) {
4577         arg2 = amglue_SvI8(ST(1));
4578       } else if (sizeof(signed int) == 2) {
4579         arg2 = amglue_SvI16(ST(1));
4580       } else if (sizeof(signed int) == 4) {
4581         arg2 = amglue_SvI32(ST(1));
4582       } else if (sizeof(signed int) == 8) {
4583         arg2 = amglue_SvI64(ST(1));
4584       } else {
4585         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4586       }
4587     }
4588     if (arg1) (arg1)->spindle = arg2;
4589     ST(argvi) = sv_newmortal();
4590
4591
4592     XSRETURN(argvi);
4593   fail:
4594
4595
4596     SWIG_croak_null();
4597   }
4598 }
4599
4600
4601 XS(_wrap_HeaderXML_spindle_get) {
4602   {
4603     dle_t *arg1 = (dle_t *) 0 ;
4604     void *argp1 = 0 ;
4605     int res1 = 0 ;
4606     int argvi = 0;
4607     int result;
4608     dXSARGS;
4609
4610     if ((items < 1) || (items > 1)) {
4611       SWIG_croak("Usage: HeaderXML_spindle_get(self);");
4612     }
4613     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4614     if (!SWIG_IsOK(res1)) {
4615       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_spindle_get" "', argument " "1"" of type '" "dle_t *""'");
4616     }
4617     arg1 = (dle_t *)(argp1);
4618     result = (int) ((arg1)->spindle);
4619     {
4620       SV *for_stack;
4621       SP += argvi; PUTBACK;
4622       for_stack = sv_2mortal(amglue_newSVi64(result));
4623       SPAGAIN; SP -= argvi;
4624       ST(argvi) = for_stack;
4625       argvi++;
4626     }
4627
4628     XSRETURN(argvi);
4629   fail:
4630
4631     SWIG_croak_null();
4632   }
4633 }
4634
4635
4636 XS(_wrap_HeaderXML_compress_set) {
4637   {
4638     dle_t *arg1 = (dle_t *) 0 ;
4639     int arg2 ;
4640     void *argp1 = 0 ;
4641     int res1 = 0 ;
4642     int argvi = 0;
4643     dXSARGS;
4644
4645     if ((items < 2) || (items > 2)) {
4646       SWIG_croak("Usage: HeaderXML_compress_set(self,compress);");
4647     }
4648     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4649     if (!SWIG_IsOK(res1)) {
4650       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_compress_set" "', argument " "1"" of type '" "dle_t *""'");
4651     }
4652     arg1 = (dle_t *)(argp1);
4653     {
4654       if (sizeof(signed int) == 1) {
4655         arg2 = amglue_SvI8(ST(1));
4656       } else if (sizeof(signed int) == 2) {
4657         arg2 = amglue_SvI16(ST(1));
4658       } else if (sizeof(signed int) == 4) {
4659         arg2 = amglue_SvI32(ST(1));
4660       } else if (sizeof(signed int) == 8) {
4661         arg2 = amglue_SvI64(ST(1));
4662       } else {
4663         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4664       }
4665     }
4666     if (arg1) (arg1)->compress = arg2;
4667     ST(argvi) = sv_newmortal();
4668
4669
4670     XSRETURN(argvi);
4671   fail:
4672
4673
4674     SWIG_croak_null();
4675   }
4676 }
4677
4678
4679 XS(_wrap_HeaderXML_compress_get) {
4680   {
4681     dle_t *arg1 = (dle_t *) 0 ;
4682     void *argp1 = 0 ;
4683     int res1 = 0 ;
4684     int argvi = 0;
4685     int result;
4686     dXSARGS;
4687
4688     if ((items < 1) || (items > 1)) {
4689       SWIG_croak("Usage: HeaderXML_compress_get(self);");
4690     }
4691     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4692     if (!SWIG_IsOK(res1)) {
4693       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_compress_get" "', argument " "1"" of type '" "dle_t *""'");
4694     }
4695     arg1 = (dle_t *)(argp1);
4696     result = (int) ((arg1)->compress);
4697     {
4698       SV *for_stack;
4699       SP += argvi; PUTBACK;
4700       for_stack = sv_2mortal(amglue_newSVi64(result));
4701       SPAGAIN; SP -= argvi;
4702       ST(argvi) = for_stack;
4703       argvi++;
4704     }
4705
4706     XSRETURN(argvi);
4707   fail:
4708
4709     SWIG_croak_null();
4710   }
4711 }
4712
4713
4714 XS(_wrap_HeaderXML_encrypt_set) {
4715   {
4716     dle_t *arg1 = (dle_t *) 0 ;
4717     int arg2 ;
4718     void *argp1 = 0 ;
4719     int res1 = 0 ;
4720     int argvi = 0;
4721     dXSARGS;
4722
4723     if ((items < 2) || (items > 2)) {
4724       SWIG_croak("Usage: HeaderXML_encrypt_set(self,encrypt);");
4725     }
4726     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4727     if (!SWIG_IsOK(res1)) {
4728       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_encrypt_set" "', argument " "1"" of type '" "dle_t *""'");
4729     }
4730     arg1 = (dle_t *)(argp1);
4731     {
4732       if (sizeof(signed int) == 1) {
4733         arg2 = amglue_SvI8(ST(1));
4734       } else if (sizeof(signed int) == 2) {
4735         arg2 = amglue_SvI16(ST(1));
4736       } else if (sizeof(signed int) == 4) {
4737         arg2 = amglue_SvI32(ST(1));
4738       } else if (sizeof(signed int) == 8) {
4739         arg2 = amglue_SvI64(ST(1));
4740       } else {
4741         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4742       }
4743     }
4744     if (arg1) (arg1)->encrypt = arg2;
4745     ST(argvi) = sv_newmortal();
4746
4747
4748     XSRETURN(argvi);
4749   fail:
4750
4751
4752     SWIG_croak_null();
4753   }
4754 }
4755
4756
4757 XS(_wrap_HeaderXML_encrypt_get) {
4758   {
4759     dle_t *arg1 = (dle_t *) 0 ;
4760     void *argp1 = 0 ;
4761     int res1 = 0 ;
4762     int argvi = 0;
4763     int result;
4764     dXSARGS;
4765
4766     if ((items < 1) || (items > 1)) {
4767       SWIG_croak("Usage: HeaderXML_encrypt_get(self);");
4768     }
4769     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4770     if (!SWIG_IsOK(res1)) {
4771       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_encrypt_get" "', argument " "1"" of type '" "dle_t *""'");
4772     }
4773     arg1 = (dle_t *)(argp1);
4774     result = (int) ((arg1)->encrypt);
4775     {
4776       SV *for_stack;
4777       SP += argvi; PUTBACK;
4778       for_stack = sv_2mortal(amglue_newSVi64(result));
4779       SPAGAIN; SP -= argvi;
4780       ST(argvi) = for_stack;
4781       argvi++;
4782     }
4783
4784     XSRETURN(argvi);
4785   fail:
4786
4787     SWIG_croak_null();
4788   }
4789 }
4790
4791
4792 XS(_wrap_HeaderXML_kencrypt_set) {
4793   {
4794     dle_t *arg1 = (dle_t *) 0 ;
4795     int arg2 ;
4796     void *argp1 = 0 ;
4797     int res1 = 0 ;
4798     int argvi = 0;
4799     dXSARGS;
4800
4801     if ((items < 2) || (items > 2)) {
4802       SWIG_croak("Usage: HeaderXML_kencrypt_set(self,kencrypt);");
4803     }
4804     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4805     if (!SWIG_IsOK(res1)) {
4806       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_kencrypt_set" "', argument " "1"" of type '" "dle_t *""'");
4807     }
4808     arg1 = (dle_t *)(argp1);
4809     {
4810       if (sizeof(signed int) == 1) {
4811         arg2 = amglue_SvI8(ST(1));
4812       } else if (sizeof(signed int) == 2) {
4813         arg2 = amglue_SvI16(ST(1));
4814       } else if (sizeof(signed int) == 4) {
4815         arg2 = amglue_SvI32(ST(1));
4816       } else if (sizeof(signed int) == 8) {
4817         arg2 = amglue_SvI64(ST(1));
4818       } else {
4819         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4820       }
4821     }
4822     if (arg1) (arg1)->kencrypt = arg2;
4823     ST(argvi) = sv_newmortal();
4824
4825
4826     XSRETURN(argvi);
4827   fail:
4828
4829
4830     SWIG_croak_null();
4831   }
4832 }
4833
4834
4835 XS(_wrap_HeaderXML_kencrypt_get) {
4836   {
4837     dle_t *arg1 = (dle_t *) 0 ;
4838     void *argp1 = 0 ;
4839     int res1 = 0 ;
4840     int argvi = 0;
4841     int result;
4842     dXSARGS;
4843
4844     if ((items < 1) || (items > 1)) {
4845       SWIG_croak("Usage: HeaderXML_kencrypt_get(self);");
4846     }
4847     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4848     if (!SWIG_IsOK(res1)) {
4849       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_kencrypt_get" "', argument " "1"" of type '" "dle_t *""'");
4850     }
4851     arg1 = (dle_t *)(argp1);
4852     result = (int) ((arg1)->kencrypt);
4853     {
4854       SV *for_stack;
4855       SP += argvi; PUTBACK;
4856       for_stack = sv_2mortal(amglue_newSVi64(result));
4857       SPAGAIN; SP -= argvi;
4858       ST(argvi) = for_stack;
4859       argvi++;
4860     }
4861
4862     XSRETURN(argvi);
4863   fail:
4864
4865     SWIG_croak_null();
4866   }
4867 }
4868
4869
4870 XS(_wrap_HeaderXML_levellist_set) {
4871   {
4872     dle_t *arg1 = (dle_t *) 0 ;
4873     levellist_t arg2 ;
4874     void *argp1 = 0 ;
4875     int res1 = 0 ;
4876     void *argp2 ;
4877     int res2 = 0 ;
4878     int argvi = 0;
4879     dXSARGS;
4880
4881     if ((items < 2) || (items > 2)) {
4882       SWIG_croak("Usage: HeaderXML_levellist_set(self,levellist);");
4883     }
4884     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4885     if (!SWIG_IsOK(res1)) {
4886       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_levellist_set" "', argument " "1"" of type '" "dle_t *""'");
4887     }
4888     arg1 = (dle_t *)(argp1);
4889     {
4890       res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_levellist_t,  0 );
4891       if (!SWIG_IsOK(res2)) {
4892         SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_levellist_set" "', argument " "2"" of type '" "levellist_t""'");
4893       }
4894       if (!argp2) {
4895         SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeaderXML_levellist_set" "', argument " "2"" of type '" "levellist_t""'");
4896       } else {
4897         arg2 = *((levellist_t *)(argp2));
4898       }
4899     }
4900     if (arg1) (arg1)->levellist = arg2;
4901     ST(argvi) = sv_newmortal();
4902
4903     XSRETURN(argvi);
4904   fail:
4905
4906     SWIG_croak_null();
4907   }
4908 }
4909
4910
4911 XS(_wrap_HeaderXML_levellist_get) {
4912   {
4913     dle_t *arg1 = (dle_t *) 0 ;
4914     void *argp1 = 0 ;
4915     int res1 = 0 ;
4916     int argvi = 0;
4917     levellist_t result;
4918     dXSARGS;
4919
4920     if ((items < 1) || (items > 1)) {
4921       SWIG_croak("Usage: HeaderXML_levellist_get(self);");
4922     }
4923     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4924     if (!SWIG_IsOK(res1)) {
4925       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_levellist_get" "', argument " "1"" of type '" "dle_t *""'");
4926     }
4927     arg1 = (dle_t *)(argp1);
4928     result =  ((arg1)->levellist);
4929     ST(argvi) = SWIG_NewPointerObj((levellist_t *)memcpy((levellist_t *)malloc(sizeof(levellist_t)),&result,sizeof(levellist_t)), SWIGTYPE_p_levellist_t, SWIG_POINTER_OWN | 0); argvi++ ;
4930
4931     XSRETURN(argvi);
4932   fail:
4933
4934     SWIG_croak_null();
4935   }
4936 }
4937
4938
4939 XS(_wrap_HeaderXML_nb_level_set) {
4940   {
4941     dle_t *arg1 = (dle_t *) 0 ;
4942     int arg2 ;
4943     void *argp1 = 0 ;
4944     int res1 = 0 ;
4945     int argvi = 0;
4946     dXSARGS;
4947
4948     if ((items < 2) || (items > 2)) {
4949       SWIG_croak("Usage: HeaderXML_nb_level_set(self,nb_level);");
4950     }
4951     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4952     if (!SWIG_IsOK(res1)) {
4953       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_nb_level_set" "', argument " "1"" of type '" "dle_t *""'");
4954     }
4955     arg1 = (dle_t *)(argp1);
4956     {
4957       if (sizeof(signed int) == 1) {
4958         arg2 = amglue_SvI8(ST(1));
4959       } else if (sizeof(signed int) == 2) {
4960         arg2 = amglue_SvI16(ST(1));
4961       } else if (sizeof(signed int) == 4) {
4962         arg2 = amglue_SvI32(ST(1));
4963       } else if (sizeof(signed int) == 8) {
4964         arg2 = amglue_SvI64(ST(1));
4965       } else {
4966         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4967       }
4968     }
4969     if (arg1) (arg1)->nb_level = arg2;
4970     ST(argvi) = sv_newmortal();
4971
4972
4973     XSRETURN(argvi);
4974   fail:
4975
4976
4977     SWIG_croak_null();
4978   }
4979 }
4980
4981
4982 XS(_wrap_HeaderXML_nb_level_get) {
4983   {
4984     dle_t *arg1 = (dle_t *) 0 ;
4985     void *argp1 = 0 ;
4986     int res1 = 0 ;
4987     int argvi = 0;
4988     int result;
4989     dXSARGS;
4990
4991     if ((items < 1) || (items > 1)) {
4992       SWIG_croak("Usage: HeaderXML_nb_level_get(self);");
4993     }
4994     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
4995     if (!SWIG_IsOK(res1)) {
4996       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_nb_level_get" "', argument " "1"" of type '" "dle_t *""'");
4997     }
4998     arg1 = (dle_t *)(argp1);
4999     result = (int) ((arg1)->nb_level);
5000     {
5001       SV *for_stack;
5002       SP += argvi; PUTBACK;
5003       for_stack = sv_2mortal(amglue_newSVi64(result));
5004       SPAGAIN; SP -= argvi;
5005       ST(argvi) = for_stack;
5006       argvi++;
5007     }
5008
5009     XSRETURN(argvi);
5010   fail:
5011
5012     SWIG_croak_null();
5013   }
5014 }
5015
5016
5017 XS(_wrap_HeaderXML_dumpdate_set) {
5018   {
5019     dle_t *arg1 = (dle_t *) 0 ;
5020     char *arg2 = (char *) 0 ;
5021     void *argp1 = 0 ;
5022     int res1 = 0 ;
5023     int res2 ;
5024     char *buf2 = 0 ;
5025     int alloc2 = 0 ;
5026     int argvi = 0;
5027     dXSARGS;
5028
5029     if ((items < 2) || (items > 2)) {
5030       SWIG_croak("Usage: HeaderXML_dumpdate_set(self,dumpdate);");
5031     }
5032     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5033     if (!SWIG_IsOK(res1)) {
5034       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_dumpdate_set" "', argument " "1"" of type '" "dle_t *""'");
5035     }
5036     arg1 = (dle_t *)(argp1);
5037     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5038     if (!SWIG_IsOK(res2)) {
5039       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_dumpdate_set" "', argument " "2"" of type '" "char *""'");
5040     }
5041     arg2 = (char *)(buf2);
5042     if (arg1->dumpdate) free((char*)arg1->dumpdate);
5043     if (arg2) {
5044       size_t size = strlen((const char *)(arg2)) + 1;
5045       arg1->dumpdate = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5046     } else {
5047       arg1->dumpdate = 0;
5048     }
5049     ST(argvi) = sv_newmortal();
5050
5051     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5052     XSRETURN(argvi);
5053   fail:
5054
5055     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5056     SWIG_croak_null();
5057   }
5058 }
5059
5060
5061 XS(_wrap_HeaderXML_dumpdate_get) {
5062   {
5063     dle_t *arg1 = (dle_t *) 0 ;
5064     void *argp1 = 0 ;
5065     int res1 = 0 ;
5066     int argvi = 0;
5067     char *result = 0 ;
5068     dXSARGS;
5069
5070     if ((items < 1) || (items > 1)) {
5071       SWIG_croak("Usage: HeaderXML_dumpdate_get(self);");
5072     }
5073     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5074     if (!SWIG_IsOK(res1)) {
5075       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_dumpdate_get" "', argument " "1"" of type '" "dle_t *""'");
5076     }
5077     arg1 = (dle_t *)(argp1);
5078     result = (char *) ((arg1)->dumpdate);
5079     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5080
5081     XSRETURN(argvi);
5082   fail:
5083
5084     SWIG_croak_null();
5085   }
5086 }
5087
5088
5089 XS(_wrap_HeaderXML_compprog_set) {
5090   {
5091     dle_t *arg1 = (dle_t *) 0 ;
5092     char *arg2 = (char *) 0 ;
5093     void *argp1 = 0 ;
5094     int res1 = 0 ;
5095     int res2 ;
5096     char *buf2 = 0 ;
5097     int alloc2 = 0 ;
5098     int argvi = 0;
5099     dXSARGS;
5100
5101     if ((items < 2) || (items > 2)) {
5102       SWIG_croak("Usage: HeaderXML_compprog_set(self,compprog);");
5103     }
5104     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5105     if (!SWIG_IsOK(res1)) {
5106       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_compprog_set" "', argument " "1"" of type '" "dle_t *""'");
5107     }
5108     arg1 = (dle_t *)(argp1);
5109     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5110     if (!SWIG_IsOK(res2)) {
5111       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_compprog_set" "', argument " "2"" of type '" "char *""'");
5112     }
5113     arg2 = (char *)(buf2);
5114     if (arg1->compprog) free((char*)arg1->compprog);
5115     if (arg2) {
5116       size_t size = strlen((const char *)(arg2)) + 1;
5117       arg1->compprog = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5118     } else {
5119       arg1->compprog = 0;
5120     }
5121     ST(argvi) = sv_newmortal();
5122
5123     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5124     XSRETURN(argvi);
5125   fail:
5126
5127     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5128     SWIG_croak_null();
5129   }
5130 }
5131
5132
5133 XS(_wrap_HeaderXML_compprog_get) {
5134   {
5135     dle_t *arg1 = (dle_t *) 0 ;
5136     void *argp1 = 0 ;
5137     int res1 = 0 ;
5138     int argvi = 0;
5139     char *result = 0 ;
5140     dXSARGS;
5141
5142     if ((items < 1) || (items > 1)) {
5143       SWIG_croak("Usage: HeaderXML_compprog_get(self);");
5144     }
5145     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5146     if (!SWIG_IsOK(res1)) {
5147       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_compprog_get" "', argument " "1"" of type '" "dle_t *""'");
5148     }
5149     arg1 = (dle_t *)(argp1);
5150     result = (char *) ((arg1)->compprog);
5151     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5152
5153     XSRETURN(argvi);
5154   fail:
5155
5156     SWIG_croak_null();
5157   }
5158 }
5159
5160
5161 XS(_wrap_HeaderXML_srv_encrypt_set) {
5162   {
5163     dle_t *arg1 = (dle_t *) 0 ;
5164     char *arg2 = (char *) 0 ;
5165     void *argp1 = 0 ;
5166     int res1 = 0 ;
5167     int res2 ;
5168     char *buf2 = 0 ;
5169     int alloc2 = 0 ;
5170     int argvi = 0;
5171     dXSARGS;
5172
5173     if ((items < 2) || (items > 2)) {
5174       SWIG_croak("Usage: HeaderXML_srv_encrypt_set(self,srv_encrypt);");
5175     }
5176     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5177     if (!SWIG_IsOK(res1)) {
5178       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_srv_encrypt_set" "', argument " "1"" of type '" "dle_t *""'");
5179     }
5180     arg1 = (dle_t *)(argp1);
5181     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5182     if (!SWIG_IsOK(res2)) {
5183       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_srv_encrypt_set" "', argument " "2"" of type '" "char *""'");
5184     }
5185     arg2 = (char *)(buf2);
5186     if (arg1->srv_encrypt) free((char*)arg1->srv_encrypt);
5187     if (arg2) {
5188       size_t size = strlen((const char *)(arg2)) + 1;
5189       arg1->srv_encrypt = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5190     } else {
5191       arg1->srv_encrypt = 0;
5192     }
5193     ST(argvi) = sv_newmortal();
5194
5195     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5196     XSRETURN(argvi);
5197   fail:
5198
5199     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5200     SWIG_croak_null();
5201   }
5202 }
5203
5204
5205 XS(_wrap_HeaderXML_srv_encrypt_get) {
5206   {
5207     dle_t *arg1 = (dle_t *) 0 ;
5208     void *argp1 = 0 ;
5209     int res1 = 0 ;
5210     int argvi = 0;
5211     char *result = 0 ;
5212     dXSARGS;
5213
5214     if ((items < 1) || (items > 1)) {
5215       SWIG_croak("Usage: HeaderXML_srv_encrypt_get(self);");
5216     }
5217     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5218     if (!SWIG_IsOK(res1)) {
5219       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_srv_encrypt_get" "', argument " "1"" of type '" "dle_t *""'");
5220     }
5221     arg1 = (dle_t *)(argp1);
5222     result = (char *) ((arg1)->srv_encrypt);
5223     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5224
5225     XSRETURN(argvi);
5226   fail:
5227
5228     SWIG_croak_null();
5229   }
5230 }
5231
5232
5233 XS(_wrap_HeaderXML_clnt_encrypt_set) {
5234   {
5235     dle_t *arg1 = (dle_t *) 0 ;
5236     char *arg2 = (char *) 0 ;
5237     void *argp1 = 0 ;
5238     int res1 = 0 ;
5239     int res2 ;
5240     char *buf2 = 0 ;
5241     int alloc2 = 0 ;
5242     int argvi = 0;
5243     dXSARGS;
5244
5245     if ((items < 2) || (items > 2)) {
5246       SWIG_croak("Usage: HeaderXML_clnt_encrypt_set(self,clnt_encrypt);");
5247     }
5248     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5249     if (!SWIG_IsOK(res1)) {
5250       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_clnt_encrypt_set" "', argument " "1"" of type '" "dle_t *""'");
5251     }
5252     arg1 = (dle_t *)(argp1);
5253     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5254     if (!SWIG_IsOK(res2)) {
5255       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_clnt_encrypt_set" "', argument " "2"" of type '" "char *""'");
5256     }
5257     arg2 = (char *)(buf2);
5258     if (arg1->clnt_encrypt) free((char*)arg1->clnt_encrypt);
5259     if (arg2) {
5260       size_t size = strlen((const char *)(arg2)) + 1;
5261       arg1->clnt_encrypt = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5262     } else {
5263       arg1->clnt_encrypt = 0;
5264     }
5265     ST(argvi) = sv_newmortal();
5266
5267     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5268     XSRETURN(argvi);
5269   fail:
5270
5271     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5272     SWIG_croak_null();
5273   }
5274 }
5275
5276
5277 XS(_wrap_HeaderXML_clnt_encrypt_get) {
5278   {
5279     dle_t *arg1 = (dle_t *) 0 ;
5280     void *argp1 = 0 ;
5281     int res1 = 0 ;
5282     int argvi = 0;
5283     char *result = 0 ;
5284     dXSARGS;
5285
5286     if ((items < 1) || (items > 1)) {
5287       SWIG_croak("Usage: HeaderXML_clnt_encrypt_get(self);");
5288     }
5289     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5290     if (!SWIG_IsOK(res1)) {
5291       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_clnt_encrypt_get" "', argument " "1"" of type '" "dle_t *""'");
5292     }
5293     arg1 = (dle_t *)(argp1);
5294     result = (char *) ((arg1)->clnt_encrypt);
5295     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5296
5297     XSRETURN(argvi);
5298   fail:
5299
5300     SWIG_croak_null();
5301   }
5302 }
5303
5304
5305 XS(_wrap_HeaderXML_srv_decrypt_opt_set) {
5306   {
5307     dle_t *arg1 = (dle_t *) 0 ;
5308     char *arg2 = (char *) 0 ;
5309     void *argp1 = 0 ;
5310     int res1 = 0 ;
5311     int res2 ;
5312     char *buf2 = 0 ;
5313     int alloc2 = 0 ;
5314     int argvi = 0;
5315     dXSARGS;
5316
5317     if ((items < 2) || (items > 2)) {
5318       SWIG_croak("Usage: HeaderXML_srv_decrypt_opt_set(self,srv_decrypt_opt);");
5319     }
5320     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5321     if (!SWIG_IsOK(res1)) {
5322       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_srv_decrypt_opt_set" "', argument " "1"" of type '" "dle_t *""'");
5323     }
5324     arg1 = (dle_t *)(argp1);
5325     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5326     if (!SWIG_IsOK(res2)) {
5327       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_srv_decrypt_opt_set" "', argument " "2"" of type '" "char *""'");
5328     }
5329     arg2 = (char *)(buf2);
5330     if (arg1->srv_decrypt_opt) free((char*)arg1->srv_decrypt_opt);
5331     if (arg2) {
5332       size_t size = strlen((const char *)(arg2)) + 1;
5333       arg1->srv_decrypt_opt = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5334     } else {
5335       arg1->srv_decrypt_opt = 0;
5336     }
5337     ST(argvi) = sv_newmortal();
5338
5339     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5340     XSRETURN(argvi);
5341   fail:
5342
5343     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5344     SWIG_croak_null();
5345   }
5346 }
5347
5348
5349 XS(_wrap_HeaderXML_srv_decrypt_opt_get) {
5350   {
5351     dle_t *arg1 = (dle_t *) 0 ;
5352     void *argp1 = 0 ;
5353     int res1 = 0 ;
5354     int argvi = 0;
5355     char *result = 0 ;
5356     dXSARGS;
5357
5358     if ((items < 1) || (items > 1)) {
5359       SWIG_croak("Usage: HeaderXML_srv_decrypt_opt_get(self);");
5360     }
5361     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5362     if (!SWIG_IsOK(res1)) {
5363       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_srv_decrypt_opt_get" "', argument " "1"" of type '" "dle_t *""'");
5364     }
5365     arg1 = (dle_t *)(argp1);
5366     result = (char *) ((arg1)->srv_decrypt_opt);
5367     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5368
5369     XSRETURN(argvi);
5370   fail:
5371
5372     SWIG_croak_null();
5373   }
5374 }
5375
5376
5377 XS(_wrap_HeaderXML_clnt_decrypt_opt_set) {
5378   {
5379     dle_t *arg1 = (dle_t *) 0 ;
5380     char *arg2 = (char *) 0 ;
5381     void *argp1 = 0 ;
5382     int res1 = 0 ;
5383     int res2 ;
5384     char *buf2 = 0 ;
5385     int alloc2 = 0 ;
5386     int argvi = 0;
5387     dXSARGS;
5388
5389     if ((items < 2) || (items > 2)) {
5390       SWIG_croak("Usage: HeaderXML_clnt_decrypt_opt_set(self,clnt_decrypt_opt);");
5391     }
5392     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5393     if (!SWIG_IsOK(res1)) {
5394       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_clnt_decrypt_opt_set" "', argument " "1"" of type '" "dle_t *""'");
5395     }
5396     arg1 = (dle_t *)(argp1);
5397     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5398     if (!SWIG_IsOK(res2)) {
5399       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_clnt_decrypt_opt_set" "', argument " "2"" of type '" "char *""'");
5400     }
5401     arg2 = (char *)(buf2);
5402     if (arg1->clnt_decrypt_opt) free((char*)arg1->clnt_decrypt_opt);
5403     if (arg2) {
5404       size_t size = strlen((const char *)(arg2)) + 1;
5405       arg1->clnt_decrypt_opt = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5406     } else {
5407       arg1->clnt_decrypt_opt = 0;
5408     }
5409     ST(argvi) = sv_newmortal();
5410
5411     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5412     XSRETURN(argvi);
5413   fail:
5414
5415     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5416     SWIG_croak_null();
5417   }
5418 }
5419
5420
5421 XS(_wrap_HeaderXML_clnt_decrypt_opt_get) {
5422   {
5423     dle_t *arg1 = (dle_t *) 0 ;
5424     void *argp1 = 0 ;
5425     int res1 = 0 ;
5426     int argvi = 0;
5427     char *result = 0 ;
5428     dXSARGS;
5429
5430     if ((items < 1) || (items > 1)) {
5431       SWIG_croak("Usage: HeaderXML_clnt_decrypt_opt_get(self);");
5432     }
5433     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5434     if (!SWIG_IsOK(res1)) {
5435       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_clnt_decrypt_opt_get" "', argument " "1"" of type '" "dle_t *""'");
5436     }
5437     arg1 = (dle_t *)(argp1);
5438     result = (char *) ((arg1)->clnt_decrypt_opt);
5439     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5440
5441     XSRETURN(argvi);
5442   fail:
5443
5444     SWIG_croak_null();
5445   }
5446 }
5447
5448
5449 XS(_wrap_HeaderXML_record_set) {
5450   {
5451     dle_t *arg1 = (dle_t *) 0 ;
5452     int arg2 ;
5453     void *argp1 = 0 ;
5454     int res1 = 0 ;
5455     int argvi = 0;
5456     dXSARGS;
5457
5458     if ((items < 2) || (items > 2)) {
5459       SWIG_croak("Usage: HeaderXML_record_set(self,record);");
5460     }
5461     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5462     if (!SWIG_IsOK(res1)) {
5463       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_record_set" "', argument " "1"" of type '" "dle_t *""'");
5464     }
5465     arg1 = (dle_t *)(argp1);
5466     {
5467       if (sizeof(signed int) == 1) {
5468         arg2 = amglue_SvI8(ST(1));
5469       } else if (sizeof(signed int) == 2) {
5470         arg2 = amglue_SvI16(ST(1));
5471       } else if (sizeof(signed int) == 4) {
5472         arg2 = amglue_SvI32(ST(1));
5473       } else if (sizeof(signed int) == 8) {
5474         arg2 = amglue_SvI64(ST(1));
5475       } else {
5476         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5477       }
5478     }
5479     if (arg1) (arg1)->record = arg2;
5480     ST(argvi) = sv_newmortal();
5481
5482
5483     XSRETURN(argvi);
5484   fail:
5485
5486
5487     SWIG_croak_null();
5488   }
5489 }
5490
5491
5492 XS(_wrap_HeaderXML_record_get) {
5493   {
5494     dle_t *arg1 = (dle_t *) 0 ;
5495     void *argp1 = 0 ;
5496     int res1 = 0 ;
5497     int argvi = 0;
5498     int result;
5499     dXSARGS;
5500
5501     if ((items < 1) || (items > 1)) {
5502       SWIG_croak("Usage: HeaderXML_record_get(self);");
5503     }
5504     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5505     if (!SWIG_IsOK(res1)) {
5506       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_record_get" "', argument " "1"" of type '" "dle_t *""'");
5507     }
5508     arg1 = (dle_t *)(argp1);
5509     result = (int) ((arg1)->record);
5510     {
5511       SV *for_stack;
5512       SP += argvi; PUTBACK;
5513       for_stack = sv_2mortal(amglue_newSVi64(result));
5514       SPAGAIN; SP -= argvi;
5515       ST(argvi) = for_stack;
5516       argvi++;
5517     }
5518
5519     XSRETURN(argvi);
5520   fail:
5521
5522     SWIG_croak_null();
5523   }
5524 }
5525
5526
5527 XS(_wrap_HeaderXML_create_index_set) {
5528   {
5529     dle_t *arg1 = (dle_t *) 0 ;
5530     int arg2 ;
5531     void *argp1 = 0 ;
5532     int res1 = 0 ;
5533     int argvi = 0;
5534     dXSARGS;
5535
5536     if ((items < 2) || (items > 2)) {
5537       SWIG_croak("Usage: HeaderXML_create_index_set(self,create_index);");
5538     }
5539     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5540     if (!SWIG_IsOK(res1)) {
5541       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_create_index_set" "', argument " "1"" of type '" "dle_t *""'");
5542     }
5543     arg1 = (dle_t *)(argp1);
5544     {
5545       if (sizeof(signed int) == 1) {
5546         arg2 = amglue_SvI8(ST(1));
5547       } else if (sizeof(signed int) == 2) {
5548         arg2 = amglue_SvI16(ST(1));
5549       } else if (sizeof(signed int) == 4) {
5550         arg2 = amglue_SvI32(ST(1));
5551       } else if (sizeof(signed int) == 8) {
5552         arg2 = amglue_SvI64(ST(1));
5553       } else {
5554         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5555       }
5556     }
5557     if (arg1) (arg1)->create_index = arg2;
5558     ST(argvi) = sv_newmortal();
5559
5560
5561     XSRETURN(argvi);
5562   fail:
5563
5564
5565     SWIG_croak_null();
5566   }
5567 }
5568
5569
5570 XS(_wrap_HeaderXML_create_index_get) {
5571   {
5572     dle_t *arg1 = (dle_t *) 0 ;
5573     void *argp1 = 0 ;
5574     int res1 = 0 ;
5575     int argvi = 0;
5576     int result;
5577     dXSARGS;
5578
5579     if ((items < 1) || (items > 1)) {
5580       SWIG_croak("Usage: HeaderXML_create_index_get(self);");
5581     }
5582     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5583     if (!SWIG_IsOK(res1)) {
5584       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_create_index_get" "', argument " "1"" of type '" "dle_t *""'");
5585     }
5586     arg1 = (dle_t *)(argp1);
5587     result = (int) ((arg1)->create_index);
5588     {
5589       SV *for_stack;
5590       SP += argvi; PUTBACK;
5591       for_stack = sv_2mortal(amglue_newSVi64(result));
5592       SPAGAIN; SP -= argvi;
5593       ST(argvi) = for_stack;
5594       argvi++;
5595     }
5596
5597     XSRETURN(argvi);
5598   fail:
5599
5600     SWIG_croak_null();
5601   }
5602 }
5603
5604
5605 XS(_wrap_HeaderXML_auth_set) {
5606   {
5607     dle_t *arg1 = (dle_t *) 0 ;
5608     char *arg2 = (char *) 0 ;
5609     void *argp1 = 0 ;
5610     int res1 = 0 ;
5611     int res2 ;
5612     char *buf2 = 0 ;
5613     int alloc2 = 0 ;
5614     int argvi = 0;
5615     dXSARGS;
5616
5617     if ((items < 2) || (items > 2)) {
5618       SWIG_croak("Usage: HeaderXML_auth_set(self,auth);");
5619     }
5620     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5621     if (!SWIG_IsOK(res1)) {
5622       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_auth_set" "', argument " "1"" of type '" "dle_t *""'");
5623     }
5624     arg1 = (dle_t *)(argp1);
5625     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5626     if (!SWIG_IsOK(res2)) {
5627       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_auth_set" "', argument " "2"" of type '" "char *""'");
5628     }
5629     arg2 = (char *)(buf2);
5630     if (arg1->auth) free((char*)arg1->auth);
5631     if (arg2) {
5632       size_t size = strlen((const char *)(arg2)) + 1;
5633       arg1->auth = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5634     } else {
5635       arg1->auth = 0;
5636     }
5637     ST(argvi) = sv_newmortal();
5638
5639     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5640     XSRETURN(argvi);
5641   fail:
5642
5643     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5644     SWIG_croak_null();
5645   }
5646 }
5647
5648
5649 XS(_wrap_HeaderXML_auth_get) {
5650   {
5651     dle_t *arg1 = (dle_t *) 0 ;
5652     void *argp1 = 0 ;
5653     int res1 = 0 ;
5654     int argvi = 0;
5655     char *result = 0 ;
5656     dXSARGS;
5657
5658     if ((items < 1) || (items > 1)) {
5659       SWIG_croak("Usage: HeaderXML_auth_get(self);");
5660     }
5661     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5662     if (!SWIG_IsOK(res1)) {
5663       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_auth_get" "', argument " "1"" of type '" "dle_t *""'");
5664     }
5665     arg1 = (dle_t *)(argp1);
5666     result = (char *) ((arg1)->auth);
5667     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5668
5669     XSRETURN(argvi);
5670   fail:
5671
5672     SWIG_croak_null();
5673   }
5674 }
5675
5676
5677 XS(_wrap_HeaderXML_exclude_file_set) {
5678   {
5679     dle_t *arg1 = (dle_t *) 0 ;
5680     sl_t *arg2 = (sl_t *) 0 ;
5681     void *argp1 = 0 ;
5682     int res1 = 0 ;
5683     void *argp2 = 0 ;
5684     int res2 = 0 ;
5685     int argvi = 0;
5686     dXSARGS;
5687
5688     if ((items < 2) || (items > 2)) {
5689       SWIG_croak("Usage: HeaderXML_exclude_file_set(self,exclude_file);");
5690     }
5691     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5692     if (!SWIG_IsOK(res1)) {
5693       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_file_set" "', argument " "1"" of type '" "dle_t *""'");
5694     }
5695     arg1 = (dle_t *)(argp1);
5696     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_sl_t, SWIG_POINTER_DISOWN |  0 );
5697     if (!SWIG_IsOK(res2)) {
5698       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_exclude_file_set" "', argument " "2"" of type '" "sl_t *""'");
5699     }
5700     arg2 = (sl_t *)(argp2);
5701     if (arg1) (arg1)->exclude_file = arg2;
5702     ST(argvi) = sv_newmortal();
5703
5704
5705     XSRETURN(argvi);
5706   fail:
5707
5708
5709     SWIG_croak_null();
5710   }
5711 }
5712
5713
5714 XS(_wrap_HeaderXML_exclude_file_get) {
5715   {
5716     dle_t *arg1 = (dle_t *) 0 ;
5717     void *argp1 = 0 ;
5718     int res1 = 0 ;
5719     int argvi = 0;
5720     sl_t *result = 0 ;
5721     dXSARGS;
5722
5723     if ((items < 1) || (items > 1)) {
5724       SWIG_croak("Usage: HeaderXML_exclude_file_get(self);");
5725     }
5726     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5727     if (!SWIG_IsOK(res1)) {
5728       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_file_get" "', argument " "1"" of type '" "dle_t *""'");
5729     }
5730     arg1 = (dle_t *)(argp1);
5731     result = (sl_t *) ((arg1)->exclude_file);
5732     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sl_t, 0 | 0); argvi++ ;
5733
5734     XSRETURN(argvi);
5735   fail:
5736
5737     SWIG_croak_null();
5738   }
5739 }
5740
5741
5742 XS(_wrap_HeaderXML_exclude_list_set) {
5743   {
5744     dle_t *arg1 = (dle_t *) 0 ;
5745     sl_t *arg2 = (sl_t *) 0 ;
5746     void *argp1 = 0 ;
5747     int res1 = 0 ;
5748     void *argp2 = 0 ;
5749     int res2 = 0 ;
5750     int argvi = 0;
5751     dXSARGS;
5752
5753     if ((items < 2) || (items > 2)) {
5754       SWIG_croak("Usage: HeaderXML_exclude_list_set(self,exclude_list);");
5755     }
5756     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5757     if (!SWIG_IsOK(res1)) {
5758       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_list_set" "', argument " "1"" of type '" "dle_t *""'");
5759     }
5760     arg1 = (dle_t *)(argp1);
5761     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_sl_t, SWIG_POINTER_DISOWN |  0 );
5762     if (!SWIG_IsOK(res2)) {
5763       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_exclude_list_set" "', argument " "2"" of type '" "sl_t *""'");
5764     }
5765     arg2 = (sl_t *)(argp2);
5766     if (arg1) (arg1)->exclude_list = arg2;
5767     ST(argvi) = sv_newmortal();
5768
5769
5770     XSRETURN(argvi);
5771   fail:
5772
5773
5774     SWIG_croak_null();
5775   }
5776 }
5777
5778
5779 XS(_wrap_HeaderXML_exclude_list_get) {
5780   {
5781     dle_t *arg1 = (dle_t *) 0 ;
5782     void *argp1 = 0 ;
5783     int res1 = 0 ;
5784     int argvi = 0;
5785     sl_t *result = 0 ;
5786     dXSARGS;
5787
5788     if ((items < 1) || (items > 1)) {
5789       SWIG_croak("Usage: HeaderXML_exclude_list_get(self);");
5790     }
5791     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5792     if (!SWIG_IsOK(res1)) {
5793       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_list_get" "', argument " "1"" of type '" "dle_t *""'");
5794     }
5795     arg1 = (dle_t *)(argp1);
5796     result = (sl_t *) ((arg1)->exclude_list);
5797     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sl_t, 0 | 0); argvi++ ;
5798
5799     XSRETURN(argvi);
5800   fail:
5801
5802     SWIG_croak_null();
5803   }
5804 }
5805
5806
5807 XS(_wrap_HeaderXML_include_file_set) {
5808   {
5809     dle_t *arg1 = (dle_t *) 0 ;
5810     sl_t *arg2 = (sl_t *) 0 ;
5811     void *argp1 = 0 ;
5812     int res1 = 0 ;
5813     void *argp2 = 0 ;
5814     int res2 = 0 ;
5815     int argvi = 0;
5816     dXSARGS;
5817
5818     if ((items < 2) || (items > 2)) {
5819       SWIG_croak("Usage: HeaderXML_include_file_set(self,include_file);");
5820     }
5821     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5822     if (!SWIG_IsOK(res1)) {
5823       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_file_set" "', argument " "1"" of type '" "dle_t *""'");
5824     }
5825     arg1 = (dle_t *)(argp1);
5826     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_sl_t, SWIG_POINTER_DISOWN |  0 );
5827     if (!SWIG_IsOK(res2)) {
5828       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_include_file_set" "', argument " "2"" of type '" "sl_t *""'");
5829     }
5830     arg2 = (sl_t *)(argp2);
5831     if (arg1) (arg1)->include_file = arg2;
5832     ST(argvi) = sv_newmortal();
5833
5834
5835     XSRETURN(argvi);
5836   fail:
5837
5838
5839     SWIG_croak_null();
5840   }
5841 }
5842
5843
5844 XS(_wrap_HeaderXML_include_file_get) {
5845   {
5846     dle_t *arg1 = (dle_t *) 0 ;
5847     void *argp1 = 0 ;
5848     int res1 = 0 ;
5849     int argvi = 0;
5850     sl_t *result = 0 ;
5851     dXSARGS;
5852
5853     if ((items < 1) || (items > 1)) {
5854       SWIG_croak("Usage: HeaderXML_include_file_get(self);");
5855     }
5856     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5857     if (!SWIG_IsOK(res1)) {
5858       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_file_get" "', argument " "1"" of type '" "dle_t *""'");
5859     }
5860     arg1 = (dle_t *)(argp1);
5861     result = (sl_t *) ((arg1)->include_file);
5862     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sl_t, 0 | 0); argvi++ ;
5863
5864     XSRETURN(argvi);
5865   fail:
5866
5867     SWIG_croak_null();
5868   }
5869 }
5870
5871
5872 XS(_wrap_HeaderXML_include_list_set) {
5873   {
5874     dle_t *arg1 = (dle_t *) 0 ;
5875     sl_t *arg2 = (sl_t *) 0 ;
5876     void *argp1 = 0 ;
5877     int res1 = 0 ;
5878     void *argp2 = 0 ;
5879     int res2 = 0 ;
5880     int argvi = 0;
5881     dXSARGS;
5882
5883     if ((items < 2) || (items > 2)) {
5884       SWIG_croak("Usage: HeaderXML_include_list_set(self,include_list);");
5885     }
5886     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5887     if (!SWIG_IsOK(res1)) {
5888       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_list_set" "', argument " "1"" of type '" "dle_t *""'");
5889     }
5890     arg1 = (dle_t *)(argp1);
5891     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_sl_t, SWIG_POINTER_DISOWN |  0 );
5892     if (!SWIG_IsOK(res2)) {
5893       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_include_list_set" "', argument " "2"" of type '" "sl_t *""'");
5894     }
5895     arg2 = (sl_t *)(argp2);
5896     if (arg1) (arg1)->include_list = arg2;
5897     ST(argvi) = sv_newmortal();
5898
5899
5900     XSRETURN(argvi);
5901   fail:
5902
5903
5904     SWIG_croak_null();
5905   }
5906 }
5907
5908
5909 XS(_wrap_HeaderXML_include_list_get) {
5910   {
5911     dle_t *arg1 = (dle_t *) 0 ;
5912     void *argp1 = 0 ;
5913     int res1 = 0 ;
5914     int argvi = 0;
5915     sl_t *result = 0 ;
5916     dXSARGS;
5917
5918     if ((items < 1) || (items > 1)) {
5919       SWIG_croak("Usage: HeaderXML_include_list_get(self);");
5920     }
5921     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5922     if (!SWIG_IsOK(res1)) {
5923       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_list_get" "', argument " "1"" of type '" "dle_t *""'");
5924     }
5925     arg1 = (dle_t *)(argp1);
5926     result = (sl_t *) ((arg1)->include_list);
5927     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_sl_t, 0 | 0); argvi++ ;
5928
5929     XSRETURN(argvi);
5930   fail:
5931
5932     SWIG_croak_null();
5933   }
5934 }
5935
5936
5937 XS(_wrap_HeaderXML_exclude_optional_set) {
5938   {
5939     dle_t *arg1 = (dle_t *) 0 ;
5940     int arg2 ;
5941     void *argp1 = 0 ;
5942     int res1 = 0 ;
5943     int argvi = 0;
5944     dXSARGS;
5945
5946     if ((items < 2) || (items > 2)) {
5947       SWIG_croak("Usage: HeaderXML_exclude_optional_set(self,exclude_optional);");
5948     }
5949     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5950     if (!SWIG_IsOK(res1)) {
5951       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_optional_set" "', argument " "1"" of type '" "dle_t *""'");
5952     }
5953     arg1 = (dle_t *)(argp1);
5954     {
5955       if (sizeof(signed int) == 1) {
5956         arg2 = amglue_SvI8(ST(1));
5957       } else if (sizeof(signed int) == 2) {
5958         arg2 = amglue_SvI16(ST(1));
5959       } else if (sizeof(signed int) == 4) {
5960         arg2 = amglue_SvI32(ST(1));
5961       } else if (sizeof(signed int) == 8) {
5962         arg2 = amglue_SvI64(ST(1));
5963       } else {
5964         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5965       }
5966     }
5967     if (arg1) (arg1)->exclude_optional = arg2;
5968     ST(argvi) = sv_newmortal();
5969
5970
5971     XSRETURN(argvi);
5972   fail:
5973
5974
5975     SWIG_croak_null();
5976   }
5977 }
5978
5979
5980 XS(_wrap_HeaderXML_exclude_optional_get) {
5981   {
5982     dle_t *arg1 = (dle_t *) 0 ;
5983     void *argp1 = 0 ;
5984     int res1 = 0 ;
5985     int argvi = 0;
5986     int result;
5987     dXSARGS;
5988
5989     if ((items < 1) || (items > 1)) {
5990       SWIG_croak("Usage: HeaderXML_exclude_optional_get(self);");
5991     }
5992     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
5993     if (!SWIG_IsOK(res1)) {
5994       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_optional_get" "', argument " "1"" of type '" "dle_t *""'");
5995     }
5996     arg1 = (dle_t *)(argp1);
5997     result = (int) ((arg1)->exclude_optional);
5998     {
5999       SV *for_stack;
6000       SP += argvi; PUTBACK;
6001       for_stack = sv_2mortal(amglue_newSVi64(result));
6002       SPAGAIN; SP -= argvi;
6003       ST(argvi) = for_stack;
6004       argvi++;
6005     }
6006
6007     XSRETURN(argvi);
6008   fail:
6009
6010     SWIG_croak_null();
6011   }
6012 }
6013
6014
6015 XS(_wrap_HeaderXML_include_optional_set) {
6016   {
6017     dle_t *arg1 = (dle_t *) 0 ;
6018     int arg2 ;
6019     void *argp1 = 0 ;
6020     int res1 = 0 ;
6021     int argvi = 0;
6022     dXSARGS;
6023
6024     if ((items < 2) || (items > 2)) {
6025       SWIG_croak("Usage: HeaderXML_include_optional_set(self,include_optional);");
6026     }
6027     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6028     if (!SWIG_IsOK(res1)) {
6029       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_optional_set" "', argument " "1"" of type '" "dle_t *""'");
6030     }
6031     arg1 = (dle_t *)(argp1);
6032     {
6033       if (sizeof(signed int) == 1) {
6034         arg2 = amglue_SvI8(ST(1));
6035       } else if (sizeof(signed int) == 2) {
6036         arg2 = amglue_SvI16(ST(1));
6037       } else if (sizeof(signed int) == 4) {
6038         arg2 = amglue_SvI32(ST(1));
6039       } else if (sizeof(signed int) == 8) {
6040         arg2 = amglue_SvI64(ST(1));
6041       } else {
6042         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
6043       }
6044     }
6045     if (arg1) (arg1)->include_optional = arg2;
6046     ST(argvi) = sv_newmortal();
6047
6048
6049     XSRETURN(argvi);
6050   fail:
6051
6052
6053     SWIG_croak_null();
6054   }
6055 }
6056
6057
6058 XS(_wrap_HeaderXML_include_optional_get) {
6059   {
6060     dle_t *arg1 = (dle_t *) 0 ;
6061     void *argp1 = 0 ;
6062     int res1 = 0 ;
6063     int argvi = 0;
6064     int result;
6065     dXSARGS;
6066
6067     if ((items < 1) || (items > 1)) {
6068       SWIG_croak("Usage: HeaderXML_include_optional_get(self);");
6069     }
6070     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6071     if (!SWIG_IsOK(res1)) {
6072       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_optional_get" "', argument " "1"" of type '" "dle_t *""'");
6073     }
6074     arg1 = (dle_t *)(argp1);
6075     result = (int) ((arg1)->include_optional);
6076     {
6077       SV *for_stack;
6078       SP += argvi; PUTBACK;
6079       for_stack = sv_2mortal(amglue_newSVi64(result));
6080       SPAGAIN; SP -= argvi;
6081       ST(argvi) = for_stack;
6082       argvi++;
6083     }
6084
6085     XSRETURN(argvi);
6086   fail:
6087
6088     SWIG_croak_null();
6089   }
6090 }
6091
6092
6093 XS(_wrap_HeaderXML_application_property_set) {
6094   {
6095     dle_t *arg1 = (dle_t *) 0 ;
6096     proplist_t arg2 ;
6097     void *argp1 = 0 ;
6098     int res1 = 0 ;
6099     void *argp2 ;
6100     int res2 = 0 ;
6101     int argvi = 0;
6102     dXSARGS;
6103
6104     if ((items < 2) || (items > 2)) {
6105       SWIG_croak("Usage: HeaderXML_application_property_set(self,application_property);");
6106     }
6107     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6108     if (!SWIG_IsOK(res1)) {
6109       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_application_property_set" "', argument " "1"" of type '" "dle_t *""'");
6110     }
6111     arg1 = (dle_t *)(argp1);
6112     {
6113       res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_proplist_t,  0 );
6114       if (!SWIG_IsOK(res2)) {
6115         SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_application_property_set" "', argument " "2"" of type '" "proplist_t""'");
6116       }
6117       if (!argp2) {
6118         SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeaderXML_application_property_set" "', argument " "2"" of type '" "proplist_t""'");
6119       } else {
6120         arg2 = *((proplist_t *)(argp2));
6121       }
6122     }
6123     if (arg1) (arg1)->application_property = arg2;
6124     ST(argvi) = sv_newmortal();
6125
6126     XSRETURN(argvi);
6127   fail:
6128
6129     SWIG_croak_null();
6130   }
6131 }
6132
6133
6134 XS(_wrap_HeaderXML_application_property_get) {
6135   {
6136     dle_t *arg1 = (dle_t *) 0 ;
6137     void *argp1 = 0 ;
6138     int res1 = 0 ;
6139     int argvi = 0;
6140     proplist_t result;
6141     dXSARGS;
6142
6143     if ((items < 1) || (items > 1)) {
6144       SWIG_croak("Usage: HeaderXML_application_property_get(self);");
6145     }
6146     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6147     if (!SWIG_IsOK(res1)) {
6148       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_application_property_get" "', argument " "1"" of type '" "dle_t *""'");
6149     }
6150     arg1 = (dle_t *)(argp1);
6151     result =  ((arg1)->application_property);
6152     ST(argvi) = SWIG_NewPointerObj((proplist_t *)memcpy((proplist_t *)malloc(sizeof(proplist_t)),&result,sizeof(proplist_t)), SWIGTYPE_p_proplist_t, SWIG_POINTER_OWN | 0); argvi++ ;
6153
6154     XSRETURN(argvi);
6155   fail:
6156
6157     SWIG_croak_null();
6158   }
6159 }
6160
6161
6162 XS(_wrap_HeaderXML_scriptlist_set) {
6163   {
6164     dle_t *arg1 = (dle_t *) 0 ;
6165     scriptlist_t arg2 ;
6166     void *argp1 = 0 ;
6167     int res1 = 0 ;
6168     void *argp2 ;
6169     int res2 = 0 ;
6170     int argvi = 0;
6171     dXSARGS;
6172
6173     if ((items < 2) || (items > 2)) {
6174       SWIG_croak("Usage: HeaderXML_scriptlist_set(self,scriptlist);");
6175     }
6176     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6177     if (!SWIG_IsOK(res1)) {
6178       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_scriptlist_set" "', argument " "1"" of type '" "dle_t *""'");
6179     }
6180     arg1 = (dle_t *)(argp1);
6181     {
6182       res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_scriptlist_t,  0 );
6183       if (!SWIG_IsOK(res2)) {
6184         SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_scriptlist_set" "', argument " "2"" of type '" "scriptlist_t""'");
6185       }
6186       if (!argp2) {
6187         SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeaderXML_scriptlist_set" "', argument " "2"" of type '" "scriptlist_t""'");
6188       } else {
6189         arg2 = *((scriptlist_t *)(argp2));
6190       }
6191     }
6192     if (arg1) (arg1)->scriptlist = arg2;
6193     ST(argvi) = sv_newmortal();
6194
6195     XSRETURN(argvi);
6196   fail:
6197
6198     SWIG_croak_null();
6199   }
6200 }
6201
6202
6203 XS(_wrap_HeaderXML_scriptlist_get) {
6204   {
6205     dle_t *arg1 = (dle_t *) 0 ;
6206     void *argp1 = 0 ;
6207     int res1 = 0 ;
6208     int argvi = 0;
6209     scriptlist_t result;
6210     dXSARGS;
6211
6212     if ((items < 1) || (items > 1)) {
6213       SWIG_croak("Usage: HeaderXML_scriptlist_get(self);");
6214     }
6215     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6216     if (!SWIG_IsOK(res1)) {
6217       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_scriptlist_get" "', argument " "1"" of type '" "dle_t *""'");
6218     }
6219     arg1 = (dle_t *)(argp1);
6220     result =  ((arg1)->scriptlist);
6221     ST(argvi) = SWIG_NewPointerObj((scriptlist_t *)memcpy((scriptlist_t *)malloc(sizeof(scriptlist_t)),&result,sizeof(scriptlist_t)), SWIGTYPE_p_scriptlist_t, SWIG_POINTER_OWN | 0); argvi++ ;
6222
6223     XSRETURN(argvi);
6224   fail:
6225
6226     SWIG_croak_null();
6227   }
6228 }
6229
6230
6231 XS(_wrap_HeaderXML_data_path_set) {
6232   {
6233     dle_t *arg1 = (dle_t *) 0 ;
6234     data_path_t arg2 ;
6235     void *argp1 = 0 ;
6236     int res1 = 0 ;
6237     void *argp2 ;
6238     int res2 = 0 ;
6239     int argvi = 0;
6240     dXSARGS;
6241
6242     if ((items < 2) || (items > 2)) {
6243       SWIG_croak("Usage: HeaderXML_data_path_set(self,data_path);");
6244     }
6245     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6246     if (!SWIG_IsOK(res1)) {
6247       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_data_path_set" "', argument " "1"" of type '" "dle_t *""'");
6248     }
6249     arg1 = (dle_t *)(argp1);
6250     {
6251       res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_data_path_t,  0 );
6252       if (!SWIG_IsOK(res2)) {
6253         SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_data_path_set" "', argument " "2"" of type '" "data_path_t""'");
6254       }
6255       if (!argp2) {
6256         SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeaderXML_data_path_set" "', argument " "2"" of type '" "data_path_t""'");
6257       } else {
6258         arg2 = *((data_path_t *)(argp2));
6259       }
6260     }
6261     if (arg1) (arg1)->data_path = arg2;
6262     ST(argvi) = sv_newmortal();
6263
6264     XSRETURN(argvi);
6265   fail:
6266
6267     SWIG_croak_null();
6268   }
6269 }
6270
6271
6272 XS(_wrap_HeaderXML_data_path_get) {
6273   {
6274     dle_t *arg1 = (dle_t *) 0 ;
6275     void *argp1 = 0 ;
6276     int res1 = 0 ;
6277     int argvi = 0;
6278     data_path_t result;
6279     dXSARGS;
6280
6281     if ((items < 1) || (items > 1)) {
6282       SWIG_croak("Usage: HeaderXML_data_path_get(self);");
6283     }
6284     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6285     if (!SWIG_IsOK(res1)) {
6286       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_data_path_get" "', argument " "1"" of type '" "dle_t *""'");
6287     }
6288     arg1 = (dle_t *)(argp1);
6289     result =  ((arg1)->data_path);
6290     ST(argvi) = SWIG_NewPointerObj((data_path_t *)memcpy((data_path_t *)malloc(sizeof(data_path_t)),&result,sizeof(data_path_t)), SWIGTYPE_p_data_path_t, SWIG_POINTER_OWN | 0); argvi++ ;
6291
6292     XSRETURN(argvi);
6293   fail:
6294
6295     SWIG_croak_null();
6296   }
6297 }
6298
6299
6300 XS(_wrap_HeaderXML_directtcp_list_set) {
6301   {
6302     dle_t *arg1 = (dle_t *) 0 ;
6303     GSList *arg2 = (GSList *) 0 ;
6304     void *argp1 = 0 ;
6305     int res1 = 0 ;
6306     void *argp2 = 0 ;
6307     int res2 = 0 ;
6308     int argvi = 0;
6309     dXSARGS;
6310
6311     if ((items < 2) || (items > 2)) {
6312       SWIG_croak("Usage: HeaderXML_directtcp_list_set(self,directtcp_list);");
6313     }
6314     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6315     if (!SWIG_IsOK(res1)) {
6316       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_directtcp_list_set" "', argument " "1"" of type '" "dle_t *""'");
6317     }
6318     arg1 = (dle_t *)(argp1);
6319     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_GSList, SWIG_POINTER_DISOWN |  0 );
6320     if (!SWIG_IsOK(res2)) {
6321       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_directtcp_list_set" "', argument " "2"" of type '" "GSList *""'");
6322     }
6323     arg2 = (GSList *)(argp2);
6324     if (arg1) (arg1)->directtcp_list = arg2;
6325     ST(argvi) = sv_newmortal();
6326
6327
6328     XSRETURN(argvi);
6329   fail:
6330
6331
6332     SWIG_croak_null();
6333   }
6334 }
6335
6336
6337 XS(_wrap_HeaderXML_directtcp_list_get) {
6338   {
6339     dle_t *arg1 = (dle_t *) 0 ;
6340     void *argp1 = 0 ;
6341     int res1 = 0 ;
6342     int argvi = 0;
6343     GSList *result = 0 ;
6344     dXSARGS;
6345
6346     if ((items < 1) || (items > 1)) {
6347       SWIG_croak("Usage: HeaderXML_directtcp_list_get(self);");
6348     }
6349     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6350     if (!SWIG_IsOK(res1)) {
6351       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_directtcp_list_get" "', argument " "1"" of type '" "dle_t *""'");
6352     }
6353     arg1 = (dle_t *)(argp1);
6354     result = (GSList *) ((arg1)->directtcp_list);
6355     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GSList, 0 | 0); argvi++ ;
6356
6357     XSRETURN(argvi);
6358   fail:
6359
6360     SWIG_croak_null();
6361   }
6362 }
6363
6364
6365 XS(_wrap_HeaderXML_next_set) {
6366   {
6367     dle_t *arg1 = (dle_t *) 0 ;
6368     struct a_dle_s *arg2 = (struct a_dle_s *) 0 ;
6369     void *argp1 = 0 ;
6370     int res1 = 0 ;
6371     void *argp2 = 0 ;
6372     int res2 = 0 ;
6373     int argvi = 0;
6374     dXSARGS;
6375
6376     if ((items < 2) || (items > 2)) {
6377       SWIG_croak("Usage: HeaderXML_next_set(self,next);");
6378     }
6379     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6380     if (!SWIG_IsOK(res1)) {
6381       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_next_set" "', argument " "1"" of type '" "dle_t *""'");
6382     }
6383     arg1 = (dle_t *)(argp1);
6384     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_a_dle_s, SWIG_POINTER_DISOWN |  0 );
6385     if (!SWIG_IsOK(res2)) {
6386       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_next_set" "', argument " "2"" of type '" "struct a_dle_s *""'");
6387     }
6388     arg2 = (struct a_dle_s *)(argp2);
6389     if (arg1) (arg1)->next = arg2;
6390     ST(argvi) = sv_newmortal();
6391
6392
6393     XSRETURN(argvi);
6394   fail:
6395
6396
6397     SWIG_croak_null();
6398   }
6399 }
6400
6401
6402 XS(_wrap_HeaderXML_next_get) {
6403   {
6404     dle_t *arg1 = (dle_t *) 0 ;
6405     void *argp1 = 0 ;
6406     int res1 = 0 ;
6407     int argvi = 0;
6408     struct a_dle_s *result = 0 ;
6409     dXSARGS;
6410
6411     if ((items < 1) || (items > 1)) {
6412       SWIG_croak("Usage: HeaderXML_next_get(self);");
6413     }
6414     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 |  0 );
6415     if (!SWIG_IsOK(res1)) {
6416       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_next_get" "', argument " "1"" of type '" "dle_t *""'");
6417     }
6418     arg1 = (dle_t *)(argp1);
6419     result = (struct a_dle_s *) ((arg1)->next);
6420     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_dle_s, 0 | 0); argvi++ ;
6421
6422     XSRETURN(argvi);
6423   fail:
6424
6425     SWIG_croak_null();
6426   }
6427 }
6428
6429
6430 XS(_wrap_new_HeaderXML) {
6431   {
6432     char *arg1 = (char *) 0 ;
6433     int res1 ;
6434     char *buf1 = 0 ;
6435     int alloc1 = 0 ;
6436     int argvi = 0;
6437     dle_t *result = 0 ;
6438     dXSARGS;
6439
6440     if ((items < 1) || (items > 1)) {
6441       SWIG_croak("Usage: new_HeaderXML(dle_str);");
6442     }
6443     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
6444     if (!SWIG_IsOK(res1)) {
6445       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HeaderXML" "', argument " "1"" of type '" "char *""'");
6446     }
6447     arg1 = (char *)(buf1);
6448     result = (dle_t *)new_dle_t(arg1);
6449     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dle_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
6450     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6451     XSRETURN(argvi);
6452   fail:
6453     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6454     SWIG_croak_null();
6455   }
6456 }
6457
6458
6459 XS(_wrap_delete_HeaderXML__SWIG_1) {
6460   {
6461     dle_t *arg1 = (dle_t *) 0 ;
6462     void *argp1 = 0 ;
6463     int res1 = 0 ;
6464     int argvi = 0;
6465     dXSARGS;
6466
6467     if ((items < 1) || (items > 1)) {
6468       SWIG_croak("Usage: delete_HeaderXML(self);");
6469     }
6470     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, SWIG_POINTER_DISOWN |  0 );
6471     if (!SWIG_IsOK(res1)) {
6472       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HeaderXML" "', argument " "1"" of type '" "dle_t *""'");
6473     }
6474     arg1 = (dle_t *)(argp1);
6475     free((char *) arg1);
6476     ST(argvi) = sv_newmortal();
6477
6478     XSRETURN(argvi);
6479   fail:
6480
6481     SWIG_croak_null();
6482   }
6483 }
6484
6485
6486 XS(_wrap_delete_HeaderXML) {
6487   dXSARGS;
6488
6489   {
6490     unsigned long _index = 0;
6491     SWIG_TypeRank _rank = 0;
6492     if (items == 1) {
6493       SWIG_TypeRank _ranki = 0;
6494       SWIG_TypeRank _rankm = 0;
6495       SWIG_TypeRank _pi = 1;
6496       int _v = 0;
6497       {
6498         void *vptr = 0;
6499         int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_dle_t, 0);
6500         _v = SWIG_CheckState(res);
6501       }
6502       if (!_v) goto check_1;
6503       _ranki += _v*_pi;
6504       _rankm += _pi;
6505       _pi *= SWIG_MAXCASTRANK;
6506       if (!_index || (_ranki < _rank)) {
6507         _rank = _ranki; _index = 1;
6508         if (_rank == _rankm) goto dispatch;
6509       }
6510     }
6511   check_1:
6512
6513   dispatch:
6514     switch(_index) {
6515     case 1:
6516       ++PL_markstack_ptr; SWIG_CALLXS(_wrap_delete_HeaderXML__SWIG_1); return;
6517     }
6518   }
6519
6520   croak("No matching function for overloaded 'delete_HeaderXML'");
6521   XSRETURN(0);
6522 }
6523
6524
6525
6526 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6527
6528 static swig_type_info _swigt__p_GSList = {"_p_GSList", "GSList *", 0, 0, (void*)0, 0};
6529 static swig_type_info _swigt__p_a_STRMAX__char = {"_p_a_STRMAX__char", "char (*)[STRMAX]|string_t *", 0, 0, (void*)0, 0};
6530 static swig_type_info _swigt__p_a_dle_s = {"_p_a_dle_s", "struct a_dle_s *", 0, 0, (void*)0, 0};
6531 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
6532 static swig_type_info _swigt__p_data_path_t = {"_p_data_path_t", "data_path_t *", 0, 0, (void*)0, 0};
6533 static swig_type_info _swigt__p_dle_t = {"_p_dle_t", "dle_t *", 0, 0, (void*)"Amanda::Header::HeaderXML", 0};
6534 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
6535 static swig_type_info _swigt__p_dumpfile_t = {"_p_dumpfile_t", "dumpfile_t *", 0, 0, (void*)"Amanda::Header::Header", 0};
6536 static swig_type_info _swigt__p_estimatelist_t = {"_p_estimatelist_t", "estimatelist_t *", 0, 0, (void*)0, 0};
6537 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
6538 static swig_type_info _swigt__p_int = {"_p_int", "int *|filetype_t *|gboolean *", 0, 0, (void*)0, 0};
6539 static swig_type_info _swigt__p_levellist_t = {"_p_levellist_t", "levellist_t *", 0, 0, (void*)0, 0};
6540 static swig_type_info _swigt__p_off_t = {"_p_off_t", "off_t *", 0, 0, (void*)0, 0};
6541 static swig_type_info _swigt__p_proplist_t = {"_p_proplist_t", "proplist_t *", 0, 0, (void*)0, 0};
6542 static swig_type_info _swigt__p_scriptlist_t = {"_p_scriptlist_t", "scriptlist_t *", 0, 0, (void*)0, 0};
6543 static swig_type_info _swigt__p_sl_t = {"_p_sl_t", "sl_t *", 0, 0, (void*)0, 0};
6544 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
6545
6546 static swig_type_info *swig_type_initial[] = {
6547   &_swigt__p_GSList,
6548   &_swigt__p_a_STRMAX__char,
6549   &_swigt__p_a_dle_s,
6550   &_swigt__p_char,
6551   &_swigt__p_data_path_t,
6552   &_swigt__p_dle_t,
6553   &_swigt__p_double,
6554   &_swigt__p_dumpfile_t,
6555   &_swigt__p_estimatelist_t,
6556   &_swigt__p_float,
6557   &_swigt__p_int,
6558   &_swigt__p_levellist_t,
6559   &_swigt__p_off_t,
6560   &_swigt__p_proplist_t,
6561   &_swigt__p_scriptlist_t,
6562   &_swigt__p_sl_t,
6563   &_swigt__p_unsigned_char,
6564 };
6565
6566 static swig_cast_info _swigc__p_GSList[] = {  {&_swigt__p_GSList, 0, 0, 0},{0, 0, 0, 0}};
6567 static swig_cast_info _swigc__p_a_STRMAX__char[] = {  {&_swigt__p_a_STRMAX__char, 0, 0, 0},{0, 0, 0, 0}};
6568 static swig_cast_info _swigc__p_a_dle_s[] = {  {&_swigt__p_a_dle_s, 0, 0, 0},{0, 0, 0, 0}};
6569 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
6570 static swig_cast_info _swigc__p_data_path_t[] = {  {&_swigt__p_data_path_t, 0, 0, 0},{0, 0, 0, 0}};
6571 static swig_cast_info _swigc__p_dle_t[] = {  {&_swigt__p_dle_t, 0, 0, 0},{0, 0, 0, 0}};
6572 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
6573 static swig_cast_info _swigc__p_dumpfile_t[] = {  {&_swigt__p_dumpfile_t, 0, 0, 0},{0, 0, 0, 0}};
6574 static swig_cast_info _swigc__p_estimatelist_t[] = {  {&_swigt__p_estimatelist_t, 0, 0, 0},{0, 0, 0, 0}};
6575 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
6576 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
6577 static swig_cast_info _swigc__p_levellist_t[] = {  {&_swigt__p_levellist_t, 0, 0, 0},{0, 0, 0, 0}};
6578 static swig_cast_info _swigc__p_off_t[] = {  {&_swigt__p_off_t, 0, 0, 0},{0, 0, 0, 0}};
6579 static swig_cast_info _swigc__p_proplist_t[] = {  {&_swigt__p_proplist_t, 0, 0, 0},{0, 0, 0, 0}};
6580 static swig_cast_info _swigc__p_scriptlist_t[] = {  {&_swigt__p_scriptlist_t, 0, 0, 0},{0, 0, 0, 0}};
6581 static swig_cast_info _swigc__p_sl_t[] = {  {&_swigt__p_sl_t, 0, 0, 0},{0, 0, 0, 0}};
6582 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
6583
6584 static swig_cast_info *swig_cast_initial[] = {
6585   _swigc__p_GSList,
6586   _swigc__p_a_STRMAX__char,
6587   _swigc__p_a_dle_s,
6588   _swigc__p_char,
6589   _swigc__p_data_path_t,
6590   _swigc__p_dle_t,
6591   _swigc__p_double,
6592   _swigc__p_dumpfile_t,
6593   _swigc__p_estimatelist_t,
6594   _swigc__p_float,
6595   _swigc__p_int,
6596   _swigc__p_levellist_t,
6597   _swigc__p_off_t,
6598   _swigc__p_proplist_t,
6599   _swigc__p_scriptlist_t,
6600   _swigc__p_sl_t,
6601   _swigc__p_unsigned_char,
6602 };
6603
6604
6605 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6606
6607 static swig_constant_info swig_constants[] = {
6608 {0,0,0,0,0,0}
6609 };
6610 #ifdef __cplusplus
6611 }
6612 #endif
6613 static swig_variable_info swig_variables[] = {
6614 {0,0,0,0}
6615 };
6616 static swig_command_info swig_commands[] = {
6617 {"Amanda::Headerc::Header_type_set", _wrap_Header_type_set},
6618 {"Amanda::Headerc::Header_type_get", _wrap_Header_type_get},
6619 {"Amanda::Headerc::Header_datestamp_set", _wrap_Header_datestamp_set},
6620 {"Amanda::Headerc::Header_datestamp_get", _wrap_Header_datestamp_get},
6621 {"Amanda::Headerc::Header_dumplevel_set", _wrap_Header_dumplevel_set},
6622 {"Amanda::Headerc::Header_dumplevel_get", _wrap_Header_dumplevel_get},
6623 {"Amanda::Headerc::Header_compressed_set", _wrap_Header_compressed_set},
6624 {"Amanda::Headerc::Header_compressed_get", _wrap_Header_compressed_get},
6625 {"Amanda::Headerc::Header_encrypted_set", _wrap_Header_encrypted_set},
6626 {"Amanda::Headerc::Header_encrypted_get", _wrap_Header_encrypted_get},
6627 {"Amanda::Headerc::Header_comp_suffix_set", _wrap_Header_comp_suffix_set},
6628 {"Amanda::Headerc::Header_comp_suffix_get", _wrap_Header_comp_suffix_get},
6629 {"Amanda::Headerc::Header_encrypt_suffix_set", _wrap_Header_encrypt_suffix_set},
6630 {"Amanda::Headerc::Header_encrypt_suffix_get", _wrap_Header_encrypt_suffix_get},
6631 {"Amanda::Headerc::Header_name_set", _wrap_Header_name_set},
6632 {"Amanda::Headerc::Header_name_get", _wrap_Header_name_get},
6633 {"Amanda::Headerc::Header_disk_set", _wrap_Header_disk_set},
6634 {"Amanda::Headerc::Header_disk_get", _wrap_Header_disk_get},
6635 {"Amanda::Headerc::Header_program_set", _wrap_Header_program_set},
6636 {"Amanda::Headerc::Header_program_get", _wrap_Header_program_get},
6637 {"Amanda::Headerc::Header_application_set", _wrap_Header_application_set},
6638 {"Amanda::Headerc::Header_application_get", _wrap_Header_application_get},
6639 {"Amanda::Headerc::Header_srvcompprog_set", _wrap_Header_srvcompprog_set},
6640 {"Amanda::Headerc::Header_srvcompprog_get", _wrap_Header_srvcompprog_get},
6641 {"Amanda::Headerc::Header_clntcompprog_set", _wrap_Header_clntcompprog_set},
6642 {"Amanda::Headerc::Header_clntcompprog_get", _wrap_Header_clntcompprog_get},
6643 {"Amanda::Headerc::Header_srv_encrypt_set", _wrap_Header_srv_encrypt_set},
6644 {"Amanda::Headerc::Header_srv_encrypt_get", _wrap_Header_srv_encrypt_get},
6645 {"Amanda::Headerc::Header_clnt_encrypt_set", _wrap_Header_clnt_encrypt_set},
6646 {"Amanda::Headerc::Header_clnt_encrypt_get", _wrap_Header_clnt_encrypt_get},
6647 {"Amanda::Headerc::Header_recover_cmd_set", _wrap_Header_recover_cmd_set},
6648 {"Amanda::Headerc::Header_recover_cmd_get", _wrap_Header_recover_cmd_get},
6649 {"Amanda::Headerc::Header_uncompress_cmd_set", _wrap_Header_uncompress_cmd_set},
6650 {"Amanda::Headerc::Header_uncompress_cmd_get", _wrap_Header_uncompress_cmd_get},
6651 {"Amanda::Headerc::Header_decrypt_cmd_set", _wrap_Header_decrypt_cmd_set},
6652 {"Amanda::Headerc::Header_decrypt_cmd_get", _wrap_Header_decrypt_cmd_get},
6653 {"Amanda::Headerc::Header_srv_decrypt_opt_set", _wrap_Header_srv_decrypt_opt_set},
6654 {"Amanda::Headerc::Header_srv_decrypt_opt_get", _wrap_Header_srv_decrypt_opt_get},
6655 {"Amanda::Headerc::Header_clnt_decrypt_opt_set", _wrap_Header_clnt_decrypt_opt_set},
6656 {"Amanda::Headerc::Header_clnt_decrypt_opt_get", _wrap_Header_clnt_decrypt_opt_get},
6657 {"Amanda::Headerc::Header_cont_filename_set", _wrap_Header_cont_filename_set},
6658 {"Amanda::Headerc::Header_cont_filename_get", _wrap_Header_cont_filename_get},
6659 {"Amanda::Headerc::Header_dle_str_set", _wrap_Header_dle_str_set},
6660 {"Amanda::Headerc::Header_dle_str_get", _wrap_Header_dle_str_get},
6661 {"Amanda::Headerc::Header_is_partial_set", _wrap_Header_is_partial_set},
6662 {"Amanda::Headerc::Header_is_partial_get", _wrap_Header_is_partial_get},
6663 {"Amanda::Headerc::Header_partnum_set", _wrap_Header_partnum_set},
6664 {"Amanda::Headerc::Header_partnum_get", _wrap_Header_partnum_get},
6665 {"Amanda::Headerc::Header_totalparts_set", _wrap_Header_totalparts_set},
6666 {"Amanda::Headerc::Header_totalparts_get", _wrap_Header_totalparts_get},
6667 {"Amanda::Headerc::Header_blocksize_set", _wrap_Header_blocksize_set},
6668 {"Amanda::Headerc::Header_blocksize_get", _wrap_Header_blocksize_get},
6669 {"Amanda::Headerc::Header_orig_size_set", _wrap_Header_orig_size_set},
6670 {"Amanda::Headerc::Header_orig_size_get", _wrap_Header_orig_size_get},
6671 {"Amanda::Headerc::new_Header", _wrap_new_Header},
6672 {"Amanda::Headerc::Header_to_string", _wrap_Header_to_string},
6673 {"Amanda::Headerc::Header_debug_dump", _wrap_Header_debug_dump},
6674 {"Amanda::Headerc::Header_summary", _wrap_Header_summary},
6675 {"Amanda::Headerc::delete_Header", _wrap_delete_Header},
6676 {"Amanda::Headerc::C_from_string", _wrap_C_from_string},
6677 {"Amanda::Headerc::HeaderXML_disk_set", _wrap_HeaderXML_disk_set},
6678 {"Amanda::Headerc::HeaderXML_disk_get", _wrap_HeaderXML_disk_get},
6679 {"Amanda::Headerc::HeaderXML_device_set", _wrap_HeaderXML_device_set},
6680 {"Amanda::Headerc::HeaderXML_device_get", _wrap_HeaderXML_device_get},
6681 {"Amanda::Headerc::HeaderXML_program_is_application_api_set", _wrap_HeaderXML_program_is_application_api_set},
6682 {"Amanda::Headerc::HeaderXML_program_is_application_api_get", _wrap_HeaderXML_program_is_application_api_get},
6683 {"Amanda::Headerc::HeaderXML_program_set", _wrap_HeaderXML_program_set},
6684 {"Amanda::Headerc::HeaderXML_program_get", _wrap_HeaderXML_program_get},
6685 {"Amanda::Headerc::HeaderXML_estimatelist_set", _wrap_HeaderXML_estimatelist_set},
6686 {"Amanda::Headerc::HeaderXML_estimatelist_get", _wrap_HeaderXML_estimatelist_get},
6687 {"Amanda::Headerc::HeaderXML_spindle_set", _wrap_HeaderXML_spindle_set},
6688 {"Amanda::Headerc::HeaderXML_spindle_get", _wrap_HeaderXML_spindle_get},
6689 {"Amanda::Headerc::HeaderXML_compress_set", _wrap_HeaderXML_compress_set},
6690 {"Amanda::Headerc::HeaderXML_compress_get", _wrap_HeaderXML_compress_get},
6691 {"Amanda::Headerc::HeaderXML_encrypt_set", _wrap_HeaderXML_encrypt_set},
6692 {"Amanda::Headerc::HeaderXML_encrypt_get", _wrap_HeaderXML_encrypt_get},
6693 {"Amanda::Headerc::HeaderXML_kencrypt_set", _wrap_HeaderXML_kencrypt_set},
6694 {"Amanda::Headerc::HeaderXML_kencrypt_get", _wrap_HeaderXML_kencrypt_get},
6695 {"Amanda::Headerc::HeaderXML_levellist_set", _wrap_HeaderXML_levellist_set},
6696 {"Amanda::Headerc::HeaderXML_levellist_get", _wrap_HeaderXML_levellist_get},
6697 {"Amanda::Headerc::HeaderXML_nb_level_set", _wrap_HeaderXML_nb_level_set},
6698 {"Amanda::Headerc::HeaderXML_nb_level_get", _wrap_HeaderXML_nb_level_get},
6699 {"Amanda::Headerc::HeaderXML_dumpdate_set", _wrap_HeaderXML_dumpdate_set},
6700 {"Amanda::Headerc::HeaderXML_dumpdate_get", _wrap_HeaderXML_dumpdate_get},
6701 {"Amanda::Headerc::HeaderXML_compprog_set", _wrap_HeaderXML_compprog_set},
6702 {"Amanda::Headerc::HeaderXML_compprog_get", _wrap_HeaderXML_compprog_get},
6703 {"Amanda::Headerc::HeaderXML_srv_encrypt_set", _wrap_HeaderXML_srv_encrypt_set},
6704 {"Amanda::Headerc::HeaderXML_srv_encrypt_get", _wrap_HeaderXML_srv_encrypt_get},
6705 {"Amanda::Headerc::HeaderXML_clnt_encrypt_set", _wrap_HeaderXML_clnt_encrypt_set},
6706 {"Amanda::Headerc::HeaderXML_clnt_encrypt_get", _wrap_HeaderXML_clnt_encrypt_get},
6707 {"Amanda::Headerc::HeaderXML_srv_decrypt_opt_set", _wrap_HeaderXML_srv_decrypt_opt_set},
6708 {"Amanda::Headerc::HeaderXML_srv_decrypt_opt_get", _wrap_HeaderXML_srv_decrypt_opt_get},
6709 {"Amanda::Headerc::HeaderXML_clnt_decrypt_opt_set", _wrap_HeaderXML_clnt_decrypt_opt_set},
6710 {"Amanda::Headerc::HeaderXML_clnt_decrypt_opt_get", _wrap_HeaderXML_clnt_decrypt_opt_get},
6711 {"Amanda::Headerc::HeaderXML_record_set", _wrap_HeaderXML_record_set},
6712 {"Amanda::Headerc::HeaderXML_record_get", _wrap_HeaderXML_record_get},
6713 {"Amanda::Headerc::HeaderXML_create_index_set", _wrap_HeaderXML_create_index_set},
6714 {"Amanda::Headerc::HeaderXML_create_index_get", _wrap_HeaderXML_create_index_get},
6715 {"Amanda::Headerc::HeaderXML_auth_set", _wrap_HeaderXML_auth_set},
6716 {"Amanda::Headerc::HeaderXML_auth_get", _wrap_HeaderXML_auth_get},
6717 {"Amanda::Headerc::HeaderXML_exclude_file_set", _wrap_HeaderXML_exclude_file_set},
6718 {"Amanda::Headerc::HeaderXML_exclude_file_get", _wrap_HeaderXML_exclude_file_get},
6719 {"Amanda::Headerc::HeaderXML_exclude_list_set", _wrap_HeaderXML_exclude_list_set},
6720 {"Amanda::Headerc::HeaderXML_exclude_list_get", _wrap_HeaderXML_exclude_list_get},
6721 {"Amanda::Headerc::HeaderXML_include_file_set", _wrap_HeaderXML_include_file_set},
6722 {"Amanda::Headerc::HeaderXML_include_file_get", _wrap_HeaderXML_include_file_get},
6723 {"Amanda::Headerc::HeaderXML_include_list_set", _wrap_HeaderXML_include_list_set},
6724 {"Amanda::Headerc::HeaderXML_include_list_get", _wrap_HeaderXML_include_list_get},
6725 {"Amanda::Headerc::HeaderXML_exclude_optional_set", _wrap_HeaderXML_exclude_optional_set},
6726 {"Amanda::Headerc::HeaderXML_exclude_optional_get", _wrap_HeaderXML_exclude_optional_get},
6727 {"Amanda::Headerc::HeaderXML_include_optional_set", _wrap_HeaderXML_include_optional_set},
6728 {"Amanda::Headerc::HeaderXML_include_optional_get", _wrap_HeaderXML_include_optional_get},
6729 {"Amanda::Headerc::HeaderXML_application_property_set", _wrap_HeaderXML_application_property_set},
6730 {"Amanda::Headerc::HeaderXML_application_property_get", _wrap_HeaderXML_application_property_get},
6731 {"Amanda::Headerc::HeaderXML_scriptlist_set", _wrap_HeaderXML_scriptlist_set},
6732 {"Amanda::Headerc::HeaderXML_scriptlist_get", _wrap_HeaderXML_scriptlist_get},
6733 {"Amanda::Headerc::HeaderXML_data_path_set", _wrap_HeaderXML_data_path_set},
6734 {"Amanda::Headerc::HeaderXML_data_path_get", _wrap_HeaderXML_data_path_get},
6735 {"Amanda::Headerc::HeaderXML_directtcp_list_set", _wrap_HeaderXML_directtcp_list_set},
6736 {"Amanda::Headerc::HeaderXML_directtcp_list_get", _wrap_HeaderXML_directtcp_list_get},
6737 {"Amanda::Headerc::HeaderXML_next_set", _wrap_HeaderXML_next_set},
6738 {"Amanda::Headerc::HeaderXML_next_get", _wrap_HeaderXML_next_get},
6739 {"Amanda::Headerc::new_HeaderXML", _wrap_new_HeaderXML},
6740 {"Amanda::Headerc::delete_HeaderXML", _wrap_delete_HeaderXML},
6741 {0,0}
6742 };
6743 /* -----------------------------------------------------------------------------
6744  * Type initialization:
6745  * This problem is tough by the requirement that no dynamic
6746  * memory is used. Also, since swig_type_info structures store pointers to
6747  * swig_cast_info structures and swig_cast_info structures store pointers back
6748  * to swig_type_info structures, we need some lookup code at initialization.
6749  * The idea is that swig generates all the structures that are needed.
6750  * The runtime then collects these partially filled structures.
6751  * The SWIG_InitializeModule function takes these initial arrays out of
6752  * swig_module, and does all the lookup, filling in the swig_module.types
6753  * array with the correct data and linking the correct swig_cast_info
6754  * structures together.
6755  *
6756  * The generated swig_type_info structures are assigned staticly to an initial
6757  * array. We just loop through that array, and handle each type individually.
6758  * First we lookup if this type has been already loaded, and if so, use the
6759  * loaded structure instead of the generated one. Then we have to fill in the
6760  * cast linked list. The cast data is initially stored in something like a
6761  * two-dimensional array. Each row corresponds to a type (there are the same
6762  * number of rows as there are in the swig_type_initial array). Each entry in
6763  * a column is one of the swig_cast_info structures for that type.
6764  * The cast_initial array is actually an array of arrays, because each row has
6765  * a variable number of columns. So to actually build the cast linked list,
6766  * we find the array of casts associated with the type, and loop through it
6767  * adding the casts to the list. The one last trick we need to do is making
6768  * sure the type pointer in the swig_cast_info struct is correct.
6769  *
6770  * First off, we lookup the cast->type name to see if it is already loaded.
6771  * There are three cases to handle:
6772  *  1) If the cast->type has already been loaded AND the type we are adding
6773  *     casting info to has not been loaded (it is in this module), THEN we
6774  *     replace the cast->type pointer with the type pointer that has already
6775  *     been loaded.
6776  *  2) If BOTH types (the one we are adding casting info to, and the
6777  *     cast->type) are loaded, THEN the cast info has already been loaded by
6778  *     the previous module so we just ignore it.
6779  *  3) Finally, if cast->type has not already been loaded, then we add that
6780  *     swig_cast_info to the linked list (because the cast->type) pointer will
6781  *     be correct.
6782  * ----------------------------------------------------------------------------- */
6783
6784 #ifdef __cplusplus
6785 extern "C" {
6786 #if 0
6787 } /* c-mode */
6788 #endif
6789 #endif
6790
6791 #if 0
6792 #define SWIGRUNTIME_DEBUG
6793 #endif
6794
6795
6796 SWIGRUNTIME void
6797 SWIG_InitializeModule(void *clientdata) {
6798   size_t i;
6799   swig_module_info *module_head, *iter;
6800   int found, init;
6801
6802   clientdata = clientdata;
6803
6804   /* check to see if the circular list has been setup, if not, set it up */
6805   if (swig_module.next==0) {
6806     /* Initialize the swig_module */
6807     swig_module.type_initial = swig_type_initial;
6808     swig_module.cast_initial = swig_cast_initial;
6809     swig_module.next = &swig_module;
6810     init = 1;
6811   } else {
6812     init = 0;
6813   }
6814
6815   /* Try and load any already created modules */
6816   module_head = SWIG_GetModule(clientdata);
6817   if (!module_head) {
6818     /* This is the first module loaded for this interpreter */
6819     /* so set the swig module into the interpreter */
6820     SWIG_SetModule(clientdata, &swig_module);
6821     module_head = &swig_module;
6822   } else {
6823     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
6824     found=0;
6825     iter=module_head;
6826     do {
6827       if (iter==&swig_module) {
6828         found=1;
6829         break;
6830       }
6831       iter=iter->next;
6832     } while (iter!= module_head);
6833
6834     /* if the is found in the list, then all is done and we may leave */
6835     if (found) return;
6836     /* otherwise we must add out module into the list */
6837     swig_module.next = module_head->next;
6838     module_head->next = &swig_module;
6839   }
6840
6841   /* When multiple interpeters are used, a module could have already been initialized in
6842        a different interpreter, but not yet have a pointer in this interpreter.
6843        In this case, we do not want to continue adding types... everything should be
6844        set up already */
6845   if (init == 0) return;
6846
6847   /* Now work on filling in swig_module.types */
6848 #ifdef SWIGRUNTIME_DEBUG
6849   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
6850 #endif
6851   for (i = 0; i < swig_module.size; ++i) {
6852     swig_type_info *type = 0;
6853     swig_type_info *ret;
6854     swig_cast_info *cast;
6855
6856 #ifdef SWIGRUNTIME_DEBUG
6857     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6858 #endif
6859
6860     /* if there is another module already loaded */
6861     if (swig_module.next != &swig_module) {
6862       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
6863     }
6864     if (type) {
6865       /* Overwrite clientdata field */
6866 #ifdef SWIGRUNTIME_DEBUG
6867       printf("SWIG_InitializeModule: found type %s\n", type->name);
6868 #endif
6869       if (swig_module.type_initial[i]->clientdata) {
6870         type->clientdata = swig_module.type_initial[i]->clientdata;
6871 #ifdef SWIGRUNTIME_DEBUG
6872         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
6873 #endif
6874       }
6875     } else {
6876       type = swig_module.type_initial[i];
6877     }
6878
6879     /* Insert casting types */
6880     cast = swig_module.cast_initial[i];
6881     while (cast->type) {
6882       /* Don't need to add information already in the list */
6883       ret = 0;
6884 #ifdef SWIGRUNTIME_DEBUG
6885       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
6886 #endif
6887       if (swig_module.next != &swig_module) {
6888         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
6889 #ifdef SWIGRUNTIME_DEBUG
6890         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
6891 #endif
6892       }
6893       if (ret) {
6894         if (type == swig_module.type_initial[i]) {
6895 #ifdef SWIGRUNTIME_DEBUG
6896           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
6897 #endif
6898           cast->type = ret;
6899           ret = 0;
6900         } else {
6901           /* Check for casting already in the list */
6902           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
6903 #ifdef SWIGRUNTIME_DEBUG
6904           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
6905 #endif
6906           if (!ocast) ret = 0;
6907         }
6908       }
6909
6910       if (!ret) {
6911 #ifdef SWIGRUNTIME_DEBUG
6912         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
6913 #endif
6914         if (type->cast) {
6915           type->cast->prev = cast;
6916           cast->next = type->cast;
6917         }
6918         type->cast = cast;
6919       }
6920       cast++;
6921     }
6922     /* Set entry in modules->types array equal to the type */
6923     swig_module.types[i] = type;
6924   }
6925   swig_module.types[i] = 0;
6926
6927 #ifdef SWIGRUNTIME_DEBUG
6928   printf("**** SWIG_InitializeModule: Cast List ******\n");
6929   for (i = 0; i < swig_module.size; ++i) {
6930     int j = 0;
6931     swig_cast_info *cast = swig_module.cast_initial[i];
6932     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6933     while (cast->type) {
6934       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
6935       cast++;
6936       ++j;
6937     }
6938     printf("---- Total casts: %d\n",j);
6939   }
6940   printf("**** SWIG_InitializeModule: Cast List ******\n");
6941 #endif
6942 }
6943
6944 /* This function will propagate the clientdata field of type to
6945 * any new swig_type_info structures that have been added into the list
6946 * of equivalent types.  It is like calling
6947 * SWIG_TypeClientData(type, clientdata) a second time.
6948 */
6949 SWIGRUNTIME void
6950 SWIG_PropagateClientData(void) {
6951   size_t i;
6952   swig_cast_info *equiv;
6953   static int init_run = 0;
6954
6955   if (init_run) return;
6956   init_run = 1;
6957
6958   for (i = 0; i < swig_module.size; i++) {
6959     if (swig_module.types[i]->clientdata) {
6960       equiv = swig_module.types[i]->cast;
6961       while (equiv) {
6962         if (!equiv->converter) {
6963           if (equiv->type && !equiv->type->clientdata)
6964           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
6965         }
6966         equiv = equiv->next;
6967       }
6968     }
6969   }
6970 }
6971
6972 #ifdef __cplusplus
6973 #if 0
6974 {
6975   /* c-mode */
6976 #endif
6977 }
6978 #endif
6979
6980
6981
6982 #ifdef __cplusplus
6983 extern "C"
6984 #endif
6985
6986 XS(SWIG_init) {
6987   dXSARGS;
6988   int i;
6989
6990   SWIG_InitializeModule(0);
6991
6992   /* Install commands */
6993   for (i = 0; swig_commands[i].name; i++) {
6994     newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
6995   }
6996
6997   /* Install variables */
6998   for (i = 0; swig_variables[i].name; i++) {
6999     SV *sv;
7000     sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
7001     if (swig_variables[i].type) {
7002       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
7003     } else {
7004       sv_setiv(sv,(IV) 0);
7005     }
7006     swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
7007   }
7008
7009   /* Install constant */
7010   for (i = 0; swig_constants[i].type; i++) {
7011     SV *sv;
7012     sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
7013     switch(swig_constants[i].type) {
7014     case SWIG_INT:
7015       sv_setiv(sv, (IV) swig_constants[i].lvalue);
7016       break;
7017     case SWIG_FLOAT:
7018       sv_setnv(sv, (double) swig_constants[i].dvalue);
7019       break;
7020     case SWIG_STRING:
7021       sv_setpv(sv, (char *) swig_constants[i].pvalue);
7022       break;
7023     case SWIG_POINTER:
7024       SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
7025       break;
7026     case SWIG_BINARY:
7027       SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
7028       break;
7029     default:
7030       break;
7031     }
7032     SvREADONLY_on(sv);
7033   }
7034
7035   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7036     SV *sv = get_sv((char*) SWIG_prefix "F_UNKNOWN", TRUE | 0x2 | GV_ADDMULTI);
7037     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_UNKNOWN)));
7038     SvREADONLY_on(sv);
7039   } while(0) /*@SWIG@*/;
7040   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7041     SV *sv = get_sv((char*) SWIG_prefix "F_WEIRD", TRUE | 0x2 | GV_ADDMULTI);
7042     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_WEIRD)));
7043     SvREADONLY_on(sv);
7044   } while(0) /*@SWIG@*/;
7045   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7046     SV *sv = get_sv((char*) SWIG_prefix "F_TAPESTART", TRUE | 0x2 | GV_ADDMULTI);
7047     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_TAPESTART)));
7048     SvREADONLY_on(sv);
7049   } while(0) /*@SWIG@*/;
7050   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7051     SV *sv = get_sv((char*) SWIG_prefix "F_TAPEEND", TRUE | 0x2 | GV_ADDMULTI);
7052     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_TAPEEND)));
7053     SvREADONLY_on(sv);
7054   } while(0) /*@SWIG@*/;
7055   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7056     SV *sv = get_sv((char*) SWIG_prefix "F_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
7057     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_DUMPFILE)));
7058     SvREADONLY_on(sv);
7059   } while(0) /*@SWIG@*/;
7060   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7061     SV *sv = get_sv((char*) SWIG_prefix "F_CONT_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
7062     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_CONT_DUMPFILE)));
7063     SvREADONLY_on(sv);
7064   } while(0) /*@SWIG@*/;
7065   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7066     SV *sv = get_sv((char*) SWIG_prefix "F_SPLIT_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
7067     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_SPLIT_DUMPFILE)));
7068     SvREADONLY_on(sv);
7069   } while(0) /*@SWIG@*/;
7070   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7071     SV *sv = get_sv((char*) SWIG_prefix "F_EMPTY", TRUE | 0x2 | GV_ADDMULTI);
7072     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(F_EMPTY)));
7073     SvREADONLY_on(sv);
7074   } while(0) /*@SWIG@*/;
7075   SWIG_TypeClientData(SWIGTYPE_p_dumpfile_t, (void*) "Amanda::Header::Header");
7076   SWIG_TypeClientData(SWIGTYPE_p_dle_t, (void*) "Amanda::Header::HeaderXML");
7077   ST(0) = &PL_sv_yes;
7078   XSRETURN(1);
7079 }
7080