git.gag.com Git - debian/amanda/blob - perl/Amanda/Types.c

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