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