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

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.39
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #define SWIGPERL
  12 #define SWIG_CASTRANK_MODE
  13
  14 /* -----------------------------------------------------------------------------
  15  *  This section contains generic SWIG labels for method/variable
  16  *  declarations/attributes, and other compiler dependent labels.
  17  * ----------------------------------------------------------------------------- */
  18
  19 /* template workaround for compilers that cannot correctly implement the C++ standard */
  20 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  21 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  22 #  define SWIGTEMPLATEDISAMBIGUATOR template
  23 # elif defined(__HP_aCC)
  24 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  25 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  26 #  define SWIGTEMPLATEDISAMBIGUATOR template
  27 # else
  28 #  define SWIGTEMPLATEDISAMBIGUATOR
  29 # endif
  30 #endif
  31
  32 /* inline attribute */
  33 #ifndef SWIGINLINE
  34 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  35 #   define SWIGINLINE inline
  36 # else
  37 #   define SWIGINLINE
  38 # endif
  39 #endif
  40
  41 /* attribute recognised by some compilers to avoid 'unused' warnings */
  42 #ifndef SWIGUNUSED
  43 # if defined(__GNUC__)
  44 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  45 #     define SWIGUNUSED __attribute__ ((__unused__))
  46 #   else
  47 #     define SWIGUNUSED
  48 #   endif
  49 # elif defined(__ICC)
  50 #   define SWIGUNUSED __attribute__ ((__unused__))
  51 # else
  52 #   define SWIGUNUSED
  53 # endif
  54 #endif
  55
  56 #ifndef SWIG_MSC_UNSUPPRESS_4505
  57 # if defined(_MSC_VER)
  58 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  59 # endif
  60 #endif
  61
  62 #ifndef SWIGUNUSEDPARM
  63 # ifdef __cplusplus
  64 #   define SWIGUNUSEDPARM(p)
  65 # else
  66 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  67 # endif
  68 #endif
  69
  70 /* internal SWIG method */
  71 #ifndef SWIGINTERN
  72 # define SWIGINTERN static SWIGUNUSED
  73 #endif
  74
  75 /* internal inline SWIG method */
  76 #ifndef SWIGINTERNINLINE
  77 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  78 #endif
  79
  80 /* exporting methods */
  81 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  82 #  ifndef GCC_HASCLASSVISIBILITY
  83 #    define GCC_HASCLASSVISIBILITY
  84 #  endif
  85 #endif
  86
  87 #ifndef SWIGEXPORT
  88 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  89 #   if defined(STATIC_LINKED)
  90 #     define SWIGEXPORT
  91 #   else
  92 #     define SWIGEXPORT __declspec(dllexport)
  93 #   endif
  94 # else
  95 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
  96 #     define SWIGEXPORT __attribute__ ((visibility("default")))
  97 #   else
  98 #     define SWIGEXPORT
  99 #   endif
 100 # endif
 101 #endif
 102
 103 /* calling conventions for Windows */
 104 #ifndef SWIGSTDCALL
 105 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 106 #   define SWIGSTDCALL __stdcall
 107 # else
 108 #   define SWIGSTDCALL
 109 # endif
 110 #endif
 111
 112 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 113 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 114 # define _CRT_SECURE_NO_DEPRECATE
 115 #endif
 116
 117 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 118 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 119 # define _SCL_SECURE_NO_DEPRECATE
 120 #endif
 121
 122
 123 /* -----------------------------------------------------------------------------
 124  * swigrun.swg
 125  *
 126  * This file contains generic C API SWIG runtime support for pointer
 127  * type checking.
 128  * ----------------------------------------------------------------------------- */
 129
 130 /* This should only be incremented when either the layout of swig_type_info changes,
 131    or for whatever reason, the runtime changes incompatibly */
 132 #define SWIG_RUNTIME_VERSION "4"
 133
 134 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 135 #ifdef SWIG_TYPE_TABLE
 136 # define SWIG_QUOTE_STRING(x) #x
 137 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 138 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 139 #else
 140 # define SWIG_TYPE_TABLE_NAME
 141 #endif
 142
 143 /*
 144   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 145   creating a static or dynamic library from the SWIG runtime code.
 146   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
 147
 148   But only do this if strictly necessary, ie, if you have problems
 149   with your compiler or suchlike.
 150 */
 151
 152 #ifndef SWIGRUNTIME
 153 # define SWIGRUNTIME SWIGINTERN
 154 #endif
 155
 156 #ifndef SWIGRUNTIMEINLINE
 157 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 158 #endif
 159
 160 /*  Generic buffer size */
 161 #ifndef SWIG_BUFFER_SIZE
 162 # define SWIG_BUFFER_SIZE 1024
 163 #endif
 164
 165 /* Flags for pointer conversions */
 166 #define SWIG_POINTER_DISOWN        0x1
 167 #define SWIG_CAST_NEW_MEMORY       0x2
 168
 169 /* Flags for new pointer objects */
 170 #define SWIG_POINTER_OWN           0x1
 171
 172
 173 /*
 174    Flags/methods for returning states.
 175
 176    The SWIG conversion methods, as ConvertPtr, return and integer
 177    that tells if the conversion was successful or not. And if not,
 178    an error code can be returned (see swigerrors.swg for the codes).
 179
 180    Use the following macros/flags to set or process the returning
 181    states.
 182
 183    In old versions of SWIG, code such as the following was usually written:
 184
 185      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 186        // success code
 187      } else {
 188        //fail code
 189      }
 190
 191    Now you can be more explicit:
 192
 193     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 194     if (SWIG_IsOK(res)) {
 195       // success code
 196     } else {
 197       // fail code
 198     }
 199
 200    which is the same really, but now you can also do
 201
 202     Type *ptr;
 203     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 204     if (SWIG_IsOK(res)) {
 205       // success code
 206       if (SWIG_IsNewObj(res) {
 207         ...
 208         delete *ptr;
 209       } else {
 210         ...
 211       }
 212     } else {
 213       // fail code
 214     }
 215
 216    I.e., now SWIG_ConvertPtr can return new objects and you can
 217    identify the case and take care of the deallocation. Of course that
 218    also requires SWIG_ConvertPtr to return new result values, such as
 219
 220       int SWIG_ConvertPtr(obj, ptr,...) {
 221         if (<obj is ok>) {
 222           if (<need new object>) {
 223             *ptr = <ptr to new allocated object>;
 224             return SWIG_NEWOBJ;
 225           } else {
 226             *ptr = <ptr to old object>;
 227             return SWIG_OLDOBJ;
 228           }
 229         } else {
 230           return SWIG_BADOBJ;
 231         }
 232       }
 233
 234    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 235    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 236    SWIG errors code.
 237
 238    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 239    allows to return the 'cast rank', for example, if you have this
 240
 241        int food(double)
 242        int fooi(int);
 243
 244    and you call
 245
 246       food(1)   // cast rank '1'  (1 -> 1.0)
 247       fooi(1)   // cast rank '0'
 248
 249    just use the SWIG_AddCast()/SWIG_CheckState()
 250 */
 251
 252 #define SWIG_OK                    (0)
 253 #define SWIG_ERROR                 (-1)
 254 #define SWIG_IsOK(r)               (r >= 0)
 255 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 256
 257 /* The CastRankLimit says how many bits are used for the cast rank */
 258 #define SWIG_CASTRANKLIMIT         (1 << 8)
 259 /* The NewMask denotes the object was created (using new/malloc) */
 260 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 261 /* The TmpMask is for in/out typemaps that use temporal objects */
 262 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 263 /* Simple returning values */
 264 #define SWIG_BADOBJ                (SWIG_ERROR)
 265 #define SWIG_OLDOBJ                (SWIG_OK)
 266 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 267 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 268 /* Check, add and del mask methods */
 269 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 270 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 271 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 272 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 273 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 274 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 275
 276 /* Cast-Rank Mode */
 277 #if defined(SWIG_CASTRANK_MODE)
 278 #  ifndef SWIG_TypeRank
 279 #    define SWIG_TypeRank             unsigned long
 280 #  endif
 281 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 282 #    define SWIG_MAXCASTRANK          (2)
 283 #  endif
 284 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 285 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 286 SWIGINTERNINLINE int SWIG_AddCast(int r) {
 287   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 288 }
 289 SWIGINTERNINLINE int SWIG_CheckState(int r) {
 290   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
 291 }
 292 #else /* no cast-rank mode */
 293 #  define SWIG_AddCast
 294 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 295 #endif
 296
 297
 298 #include <string.h>
 299
 300 #ifdef __cplusplus
 301 extern "C" {
 302 #endif
 303
 304 typedef void *(*swig_converter_func)(void *, int *);
 305 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 306
 307 /* Structure to store information on one type */
 308 typedef struct swig_type_info {
 309   const char             *name;                 /* mangled name of this type */
 310   const char             *str;                  /* human readable name of this type */
 311   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 312   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 313   void                   *clientdata;           /* language specific type data */
 314   int                    owndata;               /* flag if the structure owns the clientdata */
 315 } swig_type_info;
 316
 317 /* Structure to store a type and conversion function used for casting */
 318 typedef struct swig_cast_info {
 319   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 320   swig_converter_func     converter;            /* function to cast the void pointers */
 321   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 322   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 323 } swig_cast_info;
 324
 325 /* Structure used to store module information
 326  * Each module generates one structure like this, and the runtime collects
 327  * all of these structures and stores them in a circularly linked list.*/
 328 typedef struct swig_module_info {
 329   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 330   size_t                 size;                  /* Number of types in this module */
 331   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 332   swig_type_info         **type_initial;        /* Array of initially generated type structures */
 333   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 334   void                    *clientdata;          /* Language specific module data */
 335 } swig_module_info;
 336
 337 /*
 338   Compare two type names skipping the space characters, therefore
 339   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 340
 341   Return 0 when the two name types are equivalent, as in
 342   strncmp, but skipping ' '.
 343 */
 344 SWIGRUNTIME int
 345 SWIG_TypeNameComp(const char *f1, const char *l1,
 346                   const char *f2, const char *l2) {
 347   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 348     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 349     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 350     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 351   }
 352   return (int)((l1 - f1) - (l2 - f2));
 353 }
 354
 355 /*
 356   Check type equivalence in a name list like <name1>|<name2>|...
 357   Return 0 if not equal, 1 if equal
 358 */
 359 SWIGRUNTIME int
 360 SWIG_TypeEquiv(const char *nb, const char *tb) {
 361   int equiv = 0;
 362   const char* te = tb + strlen(tb);
 363   const char* ne = nb;
 364   while (!equiv && *ne) {
 365     for (nb = ne; *ne; ++ne) {
 366       if (*ne == '|') break;
 367     }
 368     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 369     if (*ne) ++ne;
 370   }
 371   return equiv;
 372 }
 373
 374 /*
 375   Check type equivalence in a name list like <name1>|<name2>|...
 376   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 377 */
 378 SWIGRUNTIME int
 379 SWIG_TypeCompare(const char *nb, const char *tb) {
 380   int equiv = 0;
 381   const char* te = tb + strlen(tb);
 382   const char* ne = nb;
 383   while (!equiv && *ne) {
 384     for (nb = ne; *ne; ++ne) {
 385       if (*ne == '|') break;
 386     }
 387     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 388     if (*ne) ++ne;
 389   }
 390   return equiv;
 391 }
 392
 393
 394 /*
 395   Check the typename
 396 */
 397 SWIGRUNTIME swig_cast_info *
 398 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 399   if (ty) {
 400     swig_cast_info *iter = ty->cast;
 401     while (iter) {
 402       if (strcmp(iter->type->name, c) == 0) {
 403         if (iter == ty->cast)
 404           return iter;
 405         /* Move iter to the top of the linked list */
 406         iter->prev->next = iter->next;
 407         if (iter->next)
 408           iter->next->prev = iter->prev;
 409         iter->next = ty->cast;
 410         iter->prev = 0;
 411         if (ty->cast) ty->cast->prev = iter;
 412         ty->cast = iter;
 413         return iter;
 414       }
 415       iter = iter->next;
 416     }
 417   }
 418   return 0;
 419 }
 420
 421 /*
 422   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
 423 */
 424 SWIGRUNTIME swig_cast_info *
 425 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
 426   if (ty) {
 427     swig_cast_info *iter = ty->cast;
 428     while (iter) {
 429       if (iter->type == from) {
 430         if (iter == ty->cast)
 431           return iter;
 432         /* Move iter to the top of the linked list */
 433         iter->prev->next = iter->next;
 434         if (iter->next)
 435           iter->next->prev = iter->prev;
 436         iter->next = ty->cast;
 437         iter->prev = 0;
 438         if (ty->cast) ty->cast->prev = iter;
 439         ty->cast = iter;
 440         return iter;
 441       }
 442       iter = iter->next;
 443     }
 444   }
 445   return 0;
 446 }
 447
 448 /*
 449   Cast a pointer up an inheritance hierarchy
 450 */
 451 SWIGRUNTIMEINLINE void *
 452 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
 453   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 454 }
 455
 456 /*
 457    Dynamic pointer casting. Down an inheritance hierarchy
 458 */
 459 SWIGRUNTIME swig_type_info *
 460 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 461   swig_type_info *lastty = ty;
 462   if (!ty || !ty->dcast) return ty;
 463   while (ty && (ty->dcast)) {
 464     ty = (*ty->dcast)(ptr);
 465     if (ty) lastty = ty;
 466   }
 467   return lastty;
 468 }
 469
 470 /*
 471   Return the name associated with this type
 472 */
 473 SWIGRUNTIMEINLINE const char *
 474 SWIG_TypeName(const swig_type_info *ty) {
 475   return ty->name;
 476 }
 477
 478 /*
 479   Return the pretty name associated with this type,
 480   that is an unmangled type name in a form presentable to the user.
 481 */
 482 SWIGRUNTIME const char *
 483 SWIG_TypePrettyName(const swig_type_info *type) {
 484   /* The "str" field contains the equivalent pretty names of the
 485      type, separated by vertical-bar characters.  We choose
 486      to print the last name, as it is often (?) the most
 487      specific. */
 488   if (!type) return NULL;
 489   if (type->str != NULL) {
 490     const char *last_name = type->str;
 491     const char *s;
 492     for (s = type->str; *s; s++)
 493       if (*s == '|') last_name = s+1;
 494     return last_name;
 495   }
 496   else
 497     return type->name;
 498 }
 499
 500 /*
 501    Set the clientdata field for a type
 502 */
 503 SWIGRUNTIME void
 504 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 505   swig_cast_info *cast = ti->cast;
 506   /* if (ti->clientdata == clientdata) return; */
 507   ti->clientdata = clientdata;
 508
 509   while (cast) {
 510     if (!cast->converter) {
 511       swig_type_info *tc = cast->type;
 512       if (!tc->clientdata) {
 513         SWIG_TypeClientData(tc, clientdata);
 514       }
 515     }
 516     cast = cast->next;
 517   }
 518 }
 519 SWIGRUNTIME void
 520 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 521   SWIG_TypeClientData(ti, clientdata);
 522   ti->owndata = 1;
 523 }
 524
 525 /*
 526   Search for a swig_type_info structure only by mangled name
 527   Search is a O(log #types)
 528
 529   We start searching at module start, and finish searching when start == end.
 530   Note: if start == end at the beginning of the function, we go all the way around
 531   the circular list.
 532 */
 533 SWIGRUNTIME swig_type_info *
 534 SWIG_MangledTypeQueryModule(swig_module_info *start,
 535                             swig_module_info *end,
 536                             const char *name) {
 537   swig_module_info *iter = start;
 538   do {
 539     if (iter->size) {
 540       register size_t l = 0;
 541       register size_t r = iter->size - 1;
 542       do {
 543         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 544         register size_t i = (l + r) >> 1;
 545         const char *iname = iter->types[i]->name;
 546         if (iname) {
 547           register int compare = strcmp(name, iname);
 548           if (compare == 0) {
 549             return iter->types[i];
 550           } else if (compare < 0) {
 551             if (i) {
 552               r = i - 1;
 553             } else {
 554               break;
 555             }
 556           } else if (compare > 0) {
 557             l = i + 1;
 558           }
 559         } else {
 560           break; /* should never happen */
 561         }
 562       } while (l <= r);
 563     }
 564     iter = iter->next;
 565   } while (iter != end);
 566   return 0;
 567 }
 568
 569 /*
 570   Search for a swig_type_info structure for either a mangled name or a human readable name.
 571   It first searches the mangled names of the types, which is a O(log #types)
 572   If a type is not found it then searches the human readable names, which is O(#types).
 573
 574   We start searching at module start, and finish searching when start == end.
 575   Note: if start == end at the beginning of the function, we go all the way around
 576   the circular list.
 577 */
 578 SWIGRUNTIME swig_type_info *
 579 SWIG_TypeQueryModule(swig_module_info *start,
 580                      swig_module_info *end,
 581                      const char *name) {
 582   /* STEP 1: Search the name field using binary search */
 583   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 584   if (ret) {
 585     return ret;
 586   } else {
 587     /* STEP 2: If the type hasn't been found, do a complete search
 588        of the str field (the human readable name) */
 589     swig_module_info *iter = start;
 590     do {
 591       register size_t i = 0;
 592       for (; i < iter->size; ++i) {
 593         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 594           return iter->types[i];
 595       }
 596       iter = iter->next;
 597     } while (iter != end);
 598   }
 599
 600   /* neither found a match */
 601   return 0;
 602 }
 603
 604 /*
 605    Pack binary data into a string
 606 */
 607 SWIGRUNTIME char *
 608 SWIG_PackData(char *c, void *ptr, size_t sz) {
 609   static const char hex[17] = "0123456789abcdef";
 610   register const unsigned char *u = (unsigned char *) ptr;
 611   register const unsigned char *eu =  u + sz;
 612   for (; u != eu; ++u) {
 613     register unsigned char uu = *u;
 614     *(c++) = hex[(uu & 0xf0) >> 4];
 615     *(c++) = hex[uu & 0xf];
 616   }
 617   return c;
 618 }
 619
 620 /*
 621    Unpack binary data from a string
 622 */
 623 SWIGRUNTIME const char *
 624 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 625   register unsigned char *u = (unsigned char *) ptr;
 626   register const unsigned char *eu = u + sz;
 627   for (; u != eu; ++u) {
 628     register char d = *(c++);
 629     register unsigned char uu;
 630     if ((d >= '0') && (d <= '9'))
 631       uu = ((d - '0') << 4);
 632     else if ((d >= 'a') && (d <= 'f'))
 633       uu = ((d - ('a'-10)) << 4);
 634     else
 635       return (char *) 0;
 636     d = *(c++);
 637     if ((d >= '0') && (d <= '9'))
 638       uu |= (d - '0');
 639     else if ((d >= 'a') && (d <= 'f'))
 640       uu |= (d - ('a'-10));
 641     else
 642       return (char *) 0;
 643     *u = uu;
 644   }
 645   return c;
 646 }
 647
 648 /*
 649    Pack 'void *' into a string buffer.
 650 */
 651 SWIGRUNTIME char *
 652 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 653   char *r = buff;
 654   if ((2*sizeof(void *) + 2) > bsz) return 0;
 655   *(r++) = '_';
 656   r = SWIG_PackData(r,&ptr,sizeof(void *));
 657   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 658   strcpy(r,name);
 659   return buff;
 660 }
 661
 662 SWIGRUNTIME const char *
 663 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 664   if (*c != '_') {
 665     if (strcmp(c,"NULL") == 0) {
 666       *ptr = (void *) 0;
 667       return name;
 668     } else {
 669       return 0;
 670     }
 671   }
 672   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 673 }
 674
 675 SWIGRUNTIME char *
 676 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 677   char *r = buff;
 678   size_t lname = (name ? strlen(name) : 0);
 679   if ((2*sz + 2 + lname) > bsz) return 0;
 680   *(r++) = '_';
 681   r = SWIG_PackData(r,ptr,sz);
 682   if (lname) {
 683     strncpy(r,name,lname+1);
 684   } else {
 685     *r = 0;
 686   }
 687   return buff;
 688 }
 689
 690 SWIGRUNTIME const char *
 691 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 692   if (*c != '_') {
 693     if (strcmp(c,"NULL") == 0) {
 694       memset(ptr,0,sz);
 695       return name;
 696     } else {
 697       return 0;
 698     }
 699   }
 700   return SWIG_UnpackData(++c,ptr,sz);
 701 }
 702
 703 #ifdef __cplusplus
 704 }
 705 #endif
 706
 707 /*  Errors in SWIG */
 708 #define  SWIG_UnknownError         -1
 709 #define  SWIG_IOError              -2
 710 #define  SWIG_RuntimeError         -3
 711 #define  SWIG_IndexError           -4
 712 #define  SWIG_TypeError            -5
 713 #define  SWIG_DivisionByZero       -6
 714 #define  SWIG_OverflowError        -7
 715 #define  SWIG_SyntaxError          -8
 716 #define  SWIG_ValueError           -9
 717 #define  SWIG_SystemError          -10
 718 #define  SWIG_AttributeError       -11
 719 #define  SWIG_MemoryError          -12
 720 #define  SWIG_NullReferenceError   -13
 721
 722
 723
 724 #ifdef __cplusplus
 725 /* Needed on some windows machines---since MS plays funny games with the header files under C++ */
 726 #include <math.h>
 727 #include <stdlib.h>
 728 extern "C" {
 729 #endif
 730 #include "EXTERN.h"
 731 #include "perl.h"
 732 #include "XSUB.h"
 733
 734 /* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
 735
 736 /* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
 737 #ifndef PERL_REVISION
 738 #  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
 739 #    define PERL_PATCHLEVEL_H_IMPLICIT
 740 #    include <patchlevel.h>
 741 #  endif
 742 #  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
 743 #    include <could_not_find_Perl_patchlevel.h>
 744 #  endif
 745 #  ifndef PERL_REVISION
 746 #    define PERL_REVISION       (5)
 747 #    define PERL_VERSION        PATCHLEVEL
 748 #    define PERL_SUBVERSION     SUBVERSION
 749 #  endif
 750 #endif
 751
 752 #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
 753 #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
 754 #endif
 755
 756 #ifndef SvIOK_UV
 757 # define SvIOK_UV(sv)       (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
 758 #endif
 759
 760 #ifndef SvUOK
 761 # define SvUOK(sv)           SvIOK_UV(sv)
 762 #endif
 763
 764 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
 765 #  define PL_sv_undef               sv_undef
 766 #  define PL_na                     na
 767 #  define PL_errgv                  errgv
 768 #  define PL_sv_no                  sv_no
 769 #  define PL_sv_yes                 sv_yes
 770 #  define PL_markstack_ptr          markstack_ptr
 771 #endif
 772
 773 #ifndef IVSIZE
 774 #  ifdef LONGSIZE
 775 #    define IVSIZE LONGSIZE
 776 #  else
 777 #    define IVSIZE 4 /* A bold guess, but the best we can make. */
 778 #  endif
 779 #endif
 780
 781 #ifndef INT2PTR
 782 #  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
 783 #    define PTRV                  UV
 784 #    define INT2PTR(any,d)        (any)(d)
 785 #  else
 786 #    if PTRSIZE == LONGSIZE
 787 #      define PTRV                unsigned long
 788 #    else
 789 #      define PTRV                unsigned
 790 #    endif
 791 #    define INT2PTR(any,d)        (any)(PTRV)(d)
 792 #  endif
 793
 794 #  define NUM2PTR(any,d)  (any)(PTRV)(d)
 795 #  define PTR2IV(p)       INT2PTR(IV,p)
 796 #  define PTR2UV(p)       INT2PTR(UV,p)
 797 #  define PTR2NV(p)       NUM2PTR(NV,p)
 798
 799 #  if PTRSIZE == LONGSIZE
 800 #    define PTR2ul(p)     (unsigned long)(p)
 801 #  else
 802 #    define PTR2ul(p)     INT2PTR(unsigned long,p)
 803 #  endif
 804 #endif /* !INT2PTR */
 805
 806 #ifndef SvPV_nolen
 807 # define SvPV_nolen(x) SvPV(x,PL_na)
 808 #endif
 809
 810 #ifndef get_sv
 811 #  define get_sv perl_get_sv
 812 #endif
 813
 814 #ifndef ERRSV
 815 #  define ERRSV get_sv("@",FALSE)
 816 #endif
 817
 818 #ifndef pTHX_
 819 #define pTHX_
 820 #endif
 821
 822 #include <string.h>
 823 #ifdef __cplusplus
 824 }
 825 #endif
 826
 827 /* -----------------------------------------------------------------------------
 828  * error manipulation
 829  * ----------------------------------------------------------------------------- */
 830
 831 SWIGINTERN const char*
 832 SWIG_Perl_ErrorType(int code) {
 833   const char* type = 0;
 834   switch(code) {
 835   case SWIG_MemoryError:
 836     type = "MemoryError";
 837     break;
 838   case SWIG_IOError:
 839     type = "IOError";
 840     break;
 841   case SWIG_RuntimeError:
 842     type = "RuntimeError";
 843     break;
 844   case SWIG_IndexError:
 845     type = "IndexError";
 846     break;
 847   case SWIG_TypeError:
 848     type = "TypeError";
 849     break;
 850   case SWIG_DivisionByZero:
 851     type = "ZeroDivisionError";
 852     break;
 853   case SWIG_OverflowError:
 854     type = "OverflowError";
 855     break;
 856   case SWIG_SyntaxError:
 857     type = "SyntaxError";
 858     break;
 859   case SWIG_ValueError:
 860     type = "ValueError";
 861     break;
 862   case SWIG_SystemError:
 863     type = "SystemError";
 864     break;
 865   case SWIG_AttributeError:
 866     type = "AttributeError";
 867     break;
 868   default:
 869     type = "RuntimeError";
 870   }
 871   return type;
 872 }
 873
 874
 875
 876
 877 /* -----------------------------------------------------------------------------
 878  * perlrun.swg
 879  *
 880  * This file contains the runtime support for Perl modules
 881  * and includes code for managing global variables and pointer
 882  * type checking.
 883  * ----------------------------------------------------------------------------- */
 884
 885 #ifdef PERL_OBJECT
 886 #define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
 887 #define SWIG_PERL_OBJECT_CALL pPerl,
 888 #else
 889 #define SWIG_PERL_OBJECT_DECL
 890 #define SWIG_PERL_OBJECT_CALL
 891 #endif
 892
 893 /* Common SWIG API */
 894
 895 /* for raw pointers */
 896 #define SWIG_ConvertPtr(obj, pp, type, flags)           SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
 897 #define SWIG_NewPointerObj(p, type, flags)              SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
 898
 899 /* for raw packed data */
 900 #define SWIG_ConvertPacked(obj, p, s, type)             SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
 901 #define SWIG_NewPackedObj(p, s, type)                   SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
 902
 903 /* for class or struct pointers */
 904 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
 905 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
 906
 907 /* for C or C++ function pointers */
 908 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
 909 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
 910
 911 /* for C++ member pointers, ie, member methods */
 912 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_ConvertPacked(obj, ptr, sz, ty)
 913 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_NewPackedObj(ptr, sz, type)
 914
 915
 916 /* Runtime API */
 917
 918 #define SWIG_GetModule(clientdata)                      SWIG_Perl_GetModule()
 919 #define SWIG_SetModule(clientdata, pointer)             SWIG_Perl_SetModule(pointer)
 920
 921
 922 /* Error manipulation */
 923
 924 #define SWIG_ErrorType(code)                            SWIG_Perl_ErrorType(code)
 925 #define SWIG_Error(code, msg)                           sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg)
 926 #define SWIG_fail                                       goto fail
 927
 928 /* Perl-specific SWIG API */
 929
 930 #define SWIG_MakePtr(sv, ptr, type, flags)              SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
 931 #define SWIG_MakePackedObj(sv, p, s, type)              SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
 932 #define SWIG_SetError(str)                              SWIG_Error(SWIG_RuntimeError, str)
 933
 934
 935 #define SWIG_PERL_DECL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_DECL arg1)
 936 #define SWIG_PERL_CALL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_CALL arg1)
 937 #define SWIG_PERL_DECL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_DECL arg1, arg2)
 938 #define SWIG_PERL_CALL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_CALL arg1, arg2)
 939
 940 /* -----------------------------------------------------------------------------
 941  * pointers/data manipulation
 942  * ----------------------------------------------------------------------------- */
 943
 944 /* For backward compatibility only */
 945 #define SWIG_POINTER_EXCEPTION  0
 946
 947 #ifdef __cplusplus
 948 extern "C" {
 949 #endif
 950
 951 #define SWIG_OWNER   SWIG_POINTER_OWN
 952 #define SWIG_SHADOW  SWIG_OWNER << 1
 953
 954 #define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
 955
 956 /* SWIG Perl macros */
 957
 958 /* Macro to declare an XS function */
 959 #ifndef XSPROTO
 960 #   define XSPROTO(name) void name(pTHX_ CV* cv)
 961 #endif
 962
 963 /* Macro to call an XS function */
 964 #ifdef PERL_OBJECT
 965 #  define SWIG_CALLXS(_name) _name(cv,pPerl)
 966 #else
 967 #  ifndef MULTIPLICITY
 968 #    define SWIG_CALLXS(_name) _name(cv)
 969 #  else
 970 #    define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
 971 #  endif
 972 #endif
 973
 974 #ifdef PERL_OBJECT
 975 #define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
 976
 977 #ifdef __cplusplus
 978 extern "C" {
 979 #endif
 980 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
 981 #ifdef __cplusplus
 982 }
 983 #endif
 984
 985 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
 986 #define SWIGCLASS_STATIC
 987
 988 #else /* PERL_OBJECT */
 989
 990 #define MAGIC_PPERL
 991 #define SWIGCLASS_STATIC static SWIGUNUSED
 992
 993 #ifndef MULTIPLICITY
 994 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
 995
 996 #ifdef __cplusplus
 997 extern "C" {
 998 #endif
 999 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
1000 #ifdef __cplusplus
1001 }
1002 #endif
1003
1004 #else /* MULTIPLICITY */
1005
1006 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
1007
1008 #ifdef __cplusplus
1009 extern "C" {
1010 #endif
1011 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
1012 #ifdef __cplusplus
1013 }
1014 #endif
1015
1016 #endif /* MULTIPLICITY */
1017 #endif /* PERL_OBJECT */
1018
1019 /* Workaround for bug in perl 5.6.x croak and earlier */
1020 #if (PERL_VERSION < 8)
1021 #  ifdef PERL_OBJECT
1022 #    define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
1023 static void SWIG_Perl_croak_null(CPerlObj *pPerl)
1024 #  else
1025 static void SWIG_croak_null()
1026 #  endif
1027 {
1028   SV *err=ERRSV;
1029 #  if (PERL_VERSION < 6)
1030   croak("%_", err);
1031 #  else
1032   if (SvOK(err) && !SvROK(err)) croak("%_", err);
1033   croak(Nullch);
1034 #  endif
1035 }
1036 #else
1037 #  define SWIG_croak_null() croak(Nullch)
1038 #endif
1039
1040
1041 /*
1042    Define how strict is the cast between strings and integers/doubles
1043    when overloading between these types occurs.
1044
1045    The default is making it as strict as possible by using SWIG_AddCast
1046    when needed.
1047
1048    You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
1049    disable the SWIG_AddCast, making the casting between string and
1050    numbers less strict.
1051
1052    In the end, we try to solve the overloading between strings and
1053    numerical types in the more natural way, but if you can avoid it,
1054    well, avoid it using %rename, for example.
1055 */
1056 #ifndef SWIG_PERL_NO_STRICT_STR2NUM
1057 # ifndef SWIG_PERL_STRICT_STR2NUM
1058 #  define SWIG_PERL_STRICT_STR2NUM
1059 # endif
1060 #endif
1061 #ifdef SWIG_PERL_STRICT_STR2NUM
1062 /* string takes precedence */
1063 #define SWIG_Str2NumCast(x) SWIG_AddCast(x)
1064 #else
1065 /* number takes precedence */
1066 #define SWIG_Str2NumCast(x) x
1067 #endif
1068
1069
1070
1071 #include <stdlib.h>
1072
1073 SWIGRUNTIME const char *
1074 SWIG_Perl_TypeProxyName(const swig_type_info *type) {
1075   if (!type) return NULL;
1076   if (type->clientdata != NULL) {
1077     return (const char*) type->clientdata;
1078   }
1079   else {
1080     return type->name;
1081   }
1082 }
1083
1084 /* Identical to SWIG_TypeCheck, except for strcmp comparison */
1085 SWIGRUNTIME swig_cast_info *
1086 SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
1087   if (ty) {
1088     swig_cast_info *iter = ty->cast;
1089     while (iter) {
1090       if ( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0)) ||
1091             (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0)) ) {
1092         if (iter == ty->cast)
1093           return iter;
1094         /* Move iter to the top of the linked list */
1095         iter->prev->next = iter->next;
1096         if (iter->next)
1097           iter->next->prev = iter->prev;
1098         iter->next = ty->cast;
1099         iter->prev = 0;
1100         if (ty->cast) ty->cast->prev = iter;
1101         ty->cast = iter;
1102         return iter;
1103       }
1104       iter = iter->next;
1105     }
1106   }
1107   return 0;
1108 }
1109
1110 /* Function for getting a pointer value */
1111
1112 SWIGRUNTIME int
1113 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
1114   swig_cast_info *tc;
1115   void *voidptr = (void *)0;
1116   SV *tsv = 0;
1117   /* If magical, apply more magic */
1118   if (SvGMAGICAL(sv))
1119     mg_get(sv);
1120
1121   /* Check to see if this is an object */
1122   if (sv_isobject(sv)) {
1123     IV tmp = 0;
1124     tsv = (SV*) SvRV(sv);
1125     if ((SvTYPE(tsv) == SVt_PVHV)) {
1126       MAGIC *mg;
1127       if (SvMAGICAL(tsv)) {
1128         mg = mg_find(tsv,'P');
1129         if (mg) {
1130           sv = mg->mg_obj;
1131           if (sv_isobject(sv)) {
1132             tsv = (SV*)SvRV(sv);
1133             tmp = SvIV(tsv);
1134           }
1135         }
1136       } else {
1137         return SWIG_ERROR;
1138       }
1139     } else {
1140       tmp = SvIV(tsv);
1141     }
1142     voidptr = INT2PTR(void *,tmp);
1143   } else if (! SvOK(sv)) {            /* Check for undef */
1144     *(ptr) = (void *) 0;
1145     return SWIG_OK;
1146   } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
1147     if (!SvROK(sv)) {
1148       *(ptr) = (void *) 0;
1149       return SWIG_OK;
1150     } else {
1151       return SWIG_ERROR;
1152     }
1153   } else {                            /* Don't know what it is */
1154     return SWIG_ERROR;
1155   }
1156   if (_t) {
1157     /* Now see if the types match */
1158     char *_c = HvNAME(SvSTASH(SvRV(sv)));
1159     tc = SWIG_TypeProxyCheck(_c,_t);
1160     if (!tc) {
1161       return SWIG_ERROR;
1162     }
1163     {
1164       int newmemory = 0;
1165       *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
1166       assert(!newmemory); /* newmemory handling not yet implemented */
1167     }
1168   } else {
1169     *ptr = voidptr;
1170   }
1171
1172   /*
1173    *  DISOWN implementation: we need a perl guru to check this one.
1174    */
1175   if (tsv && (flags & SWIG_POINTER_DISOWN)) {
1176     /*
1177      *  almost copy paste code from below SWIG_POINTER_OWN setting
1178      */
1179     SV *obj = sv;
1180     HV *stash = SvSTASH(SvRV(obj));
1181     GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
1182     if (isGV(gv)) {
1183       HV *hv = GvHVn(gv);
1184       /*
1185        * To set ownership (see below), a newSViv(1) entry is added.
1186        * Hence, to remove ownership, we delete the entry.
1187        */
1188       if (hv_exists_ent(hv, obj, 0)) {
1189         hv_delete_ent(hv, obj, 0, 0);
1190       }
1191     }
1192   }
1193   return SWIG_OK;
1194 }
1195
1196 SWIGRUNTIME void
1197 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
1198   if (ptr && (flags & SWIG_SHADOW)) {
1199     SV *self;
1200     SV *obj=newSV(0);
1201     HV *hash=newHV();
1202     HV *stash;
1203     sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1204     stash=SvSTASH(SvRV(obj));
1205     if (flags & SWIG_POINTER_OWN) {
1206       HV *hv;
1207       GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1208       if (!isGV(gv))
1209         gv_init(gv, stash, "OWNER", 5, FALSE);
1210       hv=GvHVn(gv);
1211       hv_store_ent(hv, obj, newSViv(1), 0);
1212     }
1213     sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
1214     SvREFCNT_dec(obj);
1215     self=newRV_noinc((SV *)hash);
1216     sv_setsv(sv, self);
1217     SvREFCNT_dec((SV *)self);
1218     sv_bless(sv, stash);
1219   }
1220   else {
1221     sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1222   }
1223 }
1224
1225 SWIGRUNTIMEINLINE SV *
1226 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
1227   SV *result = sv_newmortal();
1228   SWIG_MakePtr(result, ptr, t, flags);
1229   return result;
1230 }
1231
1232 SWIGRUNTIME void
1233 SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
1234   char result[1024];
1235   char *r = result;
1236   if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
1237   *(r++) = '_';
1238   r = SWIG_PackData(r,ptr,sz);
1239   strcpy(r,SWIG_Perl_TypeProxyName(type));
1240   sv_setpv(sv, result);
1241 }
1242
1243 SWIGRUNTIME SV *
1244 SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
1245   SV *result = sv_newmortal();
1246   SWIG_Perl_MakePackedObj(result, ptr, sz, type);
1247   return result;
1248 }
1249
1250 /* Convert a packed value value */
1251 SWIGRUNTIME int
1252 SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
1253   swig_cast_info *tc;
1254   const char  *c = 0;
1255
1256   if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
1257   c = SvPV_nolen(obj);
1258   /* Pointer values must start with leading underscore */
1259   if (*c != '_') return SWIG_ERROR;
1260   c++;
1261   c = SWIG_UnpackData(c,ptr,sz);
1262   if (ty) {
1263     tc = SWIG_TypeCheck(c,ty);
1264     if (!tc) return SWIG_ERROR;
1265   }
1266   return SWIG_OK;
1267 }
1268
1269
1270 /* Macros for low-level exception handling */
1271 #define SWIG_croak(x)    { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
1272
1273
1274 typedef XSPROTO(SwigPerlWrapper);
1275 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
1276
1277 /* Structure for command table */
1278 typedef struct {
1279   const char         *name;
1280   SwigPerlWrapperPtr  wrapper;
1281 } swig_command_info;
1282
1283 /* Information for constant table */
1284
1285 #define SWIG_INT     1
1286 #define SWIG_FLOAT   2
1287 #define SWIG_STRING  3
1288 #define SWIG_POINTER 4
1289 #define SWIG_BINARY  5
1290
1291 /* Constant information structure */
1292 typedef struct swig_constant_info {
1293     int              type;
1294     const char      *name;
1295     long             lvalue;
1296     double           dvalue;
1297     void            *pvalue;
1298     swig_type_info **ptype;
1299 } swig_constant_info;
1300
1301
1302 /* Structure for variable table */
1303 typedef struct {
1304   const char   *name;
1305   SwigMagicFunc   set;
1306   SwigMagicFunc   get;
1307   swig_type_info  **type;
1308 } swig_variable_info;
1309
1310 /* Magic variable code */
1311 #ifndef PERL_OBJECT
1312 #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
1313   #ifndef MULTIPLICITY
1314      SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
1315   #else
1316      SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
1317   #endif
1318 #else
1319 #  define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
1320 SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
1321 #endif
1322 {
1323   MAGIC *mg;
1324   sv_magic(sv,sv,'U',(char *) name,strlen(name));
1325   mg = mg_find(sv,'U');
1326   mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
1327   mg->mg_virtual->svt_get = (SwigMagicFunc) get;
1328   mg->mg_virtual->svt_set = (SwigMagicFunc) set;
1329   mg->mg_virtual->svt_len = 0;
1330   mg->mg_virtual->svt_clear = 0;
1331   mg->mg_virtual->svt_free = 0;
1332 }
1333
1334
1335 SWIGRUNTIME swig_module_info *
1336 SWIG_Perl_GetModule(void) {
1337   static void *type_pointer = (void *)0;
1338   SV *pointer;
1339
1340   /* first check if pointer already created */
1341   if (!type_pointer) {
1342     pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
1343     if (pointer && SvOK(pointer)) {
1344       type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
1345     }
1346   }
1347
1348   return (swig_module_info *) type_pointer;
1349 }
1350
1351 SWIGRUNTIME void
1352 SWIG_Perl_SetModule(swig_module_info *module) {
1353   SV *pointer;
1354
1355   /* create a new pointer */
1356   pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
1357   sv_setiv(pointer, PTR2IV(module));
1358 }
1359
1360 #ifdef __cplusplus
1361 }
1362 #endif
1363
1364 /* Workaround perl5 global namespace pollution. Note that undefining library
1365  * functions like fopen will not solve the problem on all platforms as fopen
1366  * might be a macro on Windows but not necessarily on other operating systems. */
1367 #ifdef do_open
1368   #undef do_open
1369 #endif
1370 #ifdef do_close
1371   #undef do_close
1372 #endif
1373 #ifdef scalar
1374   #undef scalar
1375 #endif
1376 #ifdef list
1377   #undef list
1378 #endif
1379 #ifdef apply
1380   #undef apply
1381 #endif
1382 #ifdef convert
1383   #undef convert
1384 #endif
1385 #ifdef Error
1386   #undef Error
1387 #endif
1388 #ifdef form
1389   #undef form
1390 #endif
1391 #ifdef vform
1392   #undef vform
1393 #endif
1394 #ifdef LABEL
1395   #undef LABEL
1396 #endif
1397 #ifdef METHOD
1398   #undef METHOD
1399 #endif
1400 #ifdef Move
1401   #undef Move
1402 #endif
1403 #ifdef yylex
1404   #undef yylex
1405 #endif
1406 #ifdef yyparse
1407   #undef yyparse
1408 #endif
1409 #ifdef yyerror
1410   #undef yyerror
1411 #endif
1412 #ifdef invert
1413   #undef invert
1414 #endif
1415 #ifdef ref
1416   #undef ref
1417 #endif
1418 #ifdef read
1419   #undef read
1420 #endif
1421 #ifdef write
1422   #undef write
1423 #endif
1424 #ifdef eof
1425   #undef eof
1426 #endif
1427 #ifdef bool
1428   #undef bool
1429 #endif
1430 #ifdef close
1431   #undef close
1432 #endif
1433 #ifdef rewind
1434   #undef rewind
1435 #endif
1436 #ifdef free
1437   #undef free
1438 #endif
1439 #ifdef malloc
1440   #undef malloc
1441 #endif
1442 #ifdef calloc
1443   #undef calloc
1444 #endif
1445 #ifdef Stat
1446   #undef Stat
1447 #endif
1448 #ifdef check
1449   #undef check
1450 #endif
1451 #ifdef seekdir
1452   #undef seekdir
1453 #endif
1454 #ifdef open
1455   #undef open
1456 #endif
1457 #ifdef readdir
1458   #undef readdir
1459 #endif
1460 #ifdef bind
1461   #undef bind
1462 #endif
1463
1464
1465
1466 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1467
1468 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1469
1470
1471
1472   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
1473
1474
1475 /* -------- TYPES TABLE (BEGIN) -------- */
1476
1477 #define SWIGTYPE_p_application_t swig_types[0]
1478 #define SWIGTYPE_p_changer_config_t swig_types[1]
1479 #define SWIGTYPE_p_char swig_types[2]
1480 #define SWIGTYPE_p_config_overrides_t swig_types[3]
1481 #define SWIGTYPE_p_device_config_t swig_types[4]
1482 #define SWIGTYPE_p_double swig_types[5]
1483 #define SWIGTYPE_p_dumptype_t swig_types[6]
1484 #define SWIGTYPE_p_float swig_types[7]
1485 #define SWIGTYPE_p_holdingdisk_t swig_types[8]
1486 #define SWIGTYPE_p_int swig_types[9]
1487 #define SWIGTYPE_p_interface_t swig_types[10]
1488 #define SWIGTYPE_p_p_GSList swig_types[11]
1489 #define SWIGTYPE_p_p_char swig_types[12]
1490 #define SWIGTYPE_p_pp_script_t swig_types[13]
1491 #define SWIGTYPE_p_tapetype_t swig_types[14]
1492 #define SWIGTYPE_p_unsigned_char swig_types[15]
1493 static swig_type_info *swig_types[17];
1494 static swig_module_info swig_module = {swig_types, 16, 0, 0, 0, 0};
1495 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1496 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1497
1498 /* -------- TYPES TABLE (END) -------- */
1499
1500 #define SWIG_init    boot_Amanda__Config
1501
1502 #define SWIG_name   "Amanda::Configc::boot_Amanda__Config"
1503 #define SWIG_prefix "Amanda::Configc::"
1504
1505 #define SWIGVERSION 0x010339
1506 #define SWIG_VERSION SWIGVERSION
1507
1508
1509 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1510 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1511
1512
1513 #ifdef __cplusplus
1514 extern "C"
1515 #endif
1516 #ifndef PERL_OBJECT
1517 #ifndef MULTIPLICITY
1518 SWIGEXPORT void SWIG_init (CV* cv);
1519 #else
1520 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1521 #endif
1522 #else
1523 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1524 #endif
1525
1526
1527 #include "amglue.h"
1528
1529
1530 #include "amglue.h"
1531
1532
1533 #include "amglue.h"
1534
1535
1536 #include "conffile.h"
1537
1538
1539 SWIGINTERNINLINE SV *
1540 SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
1541 {
1542   SV *obj = sv_newmortal();
1543   sv_setiv(obj, (IV) value);
1544   return obj;
1545 }
1546
1547
1548 SWIGINTERNINLINE SV *
1549 SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
1550 {
1551   return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
1552 }
1553
1554
1555 SWIGINTERN swig_type_info*
1556 SWIG_pchar_descriptor(void)
1557 {
1558   static int init = 0;
1559   static swig_type_info* info = 0;
1560   if (!init) {
1561     info = SWIG_TypeQuery("_p_char");
1562     init = 1;
1563   }
1564   return info;
1565 }
1566
1567
1568 SWIGINTERN int
1569 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1570 {
1571   if (SvMAGICAL(obj)) {
1572      SV *tmp = sv_newmortal();
1573      SvSetSV(tmp, obj);
1574      obj = tmp;
1575   }
1576   if (SvPOK(obj)) {
1577     STRLEN len = 0;
1578     char *cstr = SvPV(obj, len);
1579     size_t size = len + 1;
1580     if (cptr)  {
1581       if (alloc) {
1582         if (*alloc == SWIG_NEWOBJ) {
1583           *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1584         } else {
1585           *cptr = cstr;
1586           *alloc = SWIG_OLDOBJ;
1587         }
1588       }
1589     }
1590     if (psize) *psize = size;
1591     return SWIG_OK;
1592   } else {
1593     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1594     if (pchar_descriptor) {
1595       char* vptr = 0;
1596       if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1597         if (cptr) *cptr = vptr;
1598         if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1599         if (alloc) *alloc = SWIG_OLDOBJ;
1600         return SWIG_OK;
1601       }
1602     }
1603   }
1604   return SWIG_TypeError;
1605 }
1606
1607
1608
1609
1610
1611 #include <limits.h>
1612 #if !defined(SWIG_NO_LLONG_MAX)
1613 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1614 #   define LLONG_MAX __LONG_LONG_MAX__
1615 #   define LLONG_MIN (-LLONG_MAX - 1LL)
1616 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1617 # endif
1618 #endif
1619
1620
1621 SWIGINTERN int
1622 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1623 {
1624   if (SvNIOK(obj)) {
1625     if (val) *val = SvNV(obj);
1626     return SWIG_OK;
1627   } else if (SvIOK(obj)) {
1628     if (val) *val = (double) SvIV(obj);
1629     return SWIG_AddCast(SWIG_OK);
1630   } else {
1631     const char *nptr = SvPV_nolen(obj);
1632     if (nptr) {
1633       char *endptr;
1634       double v = strtod(nptr, &endptr);
1635       if (errno == ERANGE) {
1636         errno = 0;
1637         return SWIG_OverflowError;
1638       } else {
1639         if (*endptr == '\0') {
1640           if (val) *val = v;
1641           return SWIG_Str2NumCast(SWIG_OK);
1642         }
1643       }
1644     }
1645   }
1646   return SWIG_TypeError;
1647 }
1648
1649
1650 #include <float.h>
1651
1652
1653 #include <math.h>
1654
1655
1656 SWIGINTERNINLINE int
1657 SWIG_CanCastAsInteger(double *d, double min, double max) {
1658   double x = *d;
1659   if ((min <= x && x <= max)) {
1660    double fx = floor(x);
1661    double cx = ceil(x);
1662    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1663    if ((errno == EDOM) || (errno == ERANGE)) {
1664      errno = 0;
1665    } else {
1666      double summ, reps, diff;
1667      if (rd < x) {
1668        diff = x - rd;
1669      } else if (rd > x) {
1670        diff = rd - x;
1671      } else {
1672        return 1;
1673      }
1674      summ = rd + x;
1675      reps = diff/summ;
1676      if (reps < 8*DBL_EPSILON) {
1677        *d = rd;
1678        return 1;
1679      }
1680    }
1681   }
1682   return 0;
1683 }
1684
1685
1686 SWIGINTERN int
1687 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1688 {
1689   if (SvIOK(obj)) {
1690     if (val) *val = SvIV(obj);
1691     return SWIG_OK;
1692   } else {
1693     int dispatch = 0;
1694     const char *nptr = SvPV_nolen(obj);
1695     if (nptr) {
1696       char *endptr;
1697       long v;
1698       errno = 0;
1699       v = strtol(nptr, &endptr,0);
1700       if (errno == ERANGE) {
1701         errno = 0;
1702         return SWIG_OverflowError;
1703       } else {
1704         if (*endptr == '\0') {
1705           if (val) *val = v;
1706           return SWIG_Str2NumCast(SWIG_OK);
1707         }
1708       }
1709     }
1710     if (!dispatch) {
1711       double d;
1712       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1713       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1714         if (val) *val = (long)(d);
1715         return res;
1716       }
1717     }
1718   }
1719   return SWIG_TypeError;
1720 }
1721
1722
1723 SWIGINTERN int
1724 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1725 {
1726   long v;
1727   int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1728   if (SWIG_IsOK(res)) {
1729     if ((v < INT_MIN || v > INT_MAX)) {
1730       return SWIG_OverflowError;
1731     } else {
1732       if (val) *val = (int)(v);
1733     }
1734   }
1735   return res;
1736 }
1737
1738
1739 typedef char **val_t_strs;
1740 val_t_strs getconf_byname_strs(char *key, int str_needs_quotes) {
1741     val_t *val = getconf_byname(key);
1742     if (!val) return NULL;
1743     return val_t_display_strs(val, str_needs_quotes);
1744 }
1745
1746
1747 SWIGINTERNINLINE SV *
1748 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1749 {
1750   SV *obj = sv_newmortal();
1751   if (carray) {
1752     sv_setpvn(obj, carray, size);
1753   } else {
1754     sv_setsv(obj, &PL_sv_undef);
1755   }
1756   return obj;
1757 }
1758
1759
1760 SWIGINTERNINLINE SV *
1761 SWIG_FromCharPtr(const char *cptr)
1762 {
1763   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1764 }
1765
1766 #ifdef __cplusplus
1767 extern "C" {
1768 #endif
1769
1770 #ifdef PERL_OBJECT
1771 #define MAGIC_CLASS _wrap_Amanda__Config_var::
1772 class _wrap_Amanda__Config_var : public CPerlObj {
1773 public:
1774 #else
1775 #define MAGIC_CLASS
1776 #endif
1777 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
1778     MAGIC_PPERL
1779     croak("Value is read-only.");
1780     return 0;
1781 }
1782 SWIGCLASS_STATIC int _wrap_debug_amandad_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
1783   MAGIC_PPERL
1784   {
1785     int val;
1786     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
1787     if (!SWIG_IsOK(res)) {
1788       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_amandad""' of type '""int""'");
1789     }
1790     debug_amandad = (int)(val);
1791   }
1792 fail:
1793   return 1;
1794 }
1795
1796
1797 SWIGCLASS_STATIC int _wrap_debug_amandad_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
1798   MAGIC_PPERL
1799   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_amandad)))  ;
1800   return 1;
1801 }
1802
1803
1804 SWIGCLASS_STATIC int _wrap_debug_recovery_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
1805   MAGIC_PPERL
1806   {
1807     int val;
1808     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
1809     if (!SWIG_IsOK(res)) {
1810       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_recovery""' of type '""int""'");
1811     }
1812     debug_recovery = (int)(val);
1813   }
1814 fail:
1815   return 1;
1816 }
1817
1818
1819 SWIGCLASS_STATIC int _wrap_debug_recovery_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
1820   MAGIC_PPERL
1821   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_recovery)))  ;
1822   return 1;
1823 }
1824
1825
1826 SWIGCLASS_STATIC int _wrap_debug_amidxtaped_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
1827   MAGIC_PPERL
1828   {
1829     int val;
1830     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
1831     if (!SWIG_IsOK(res)) {
1832       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_amidxtaped""' of type '""int""'");
1833     }
1834     debug_amidxtaped = (int)(val);
1835   }
1836 fail:
1837   return 1;
1838 }
1839
1840
1841 SWIGCLASS_STATIC int _wrap_debug_amidxtaped_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
1842   MAGIC_PPERL
1843   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_amidxtaped)))  ;
1844   return 1;
1845 }
1846
1847
1848 SWIGCLASS_STATIC int _wrap_debug_amindexd_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
1849   MAGIC_PPERL
1850   {
1851     int val;
1852     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
1853     if (!SWIG_IsOK(res)) {
1854       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_amindexd""' of type '""int""'");
1855     }
1856     debug_amindexd = (int)(val);
1857   }
1858 fail:
1859   return 1;
1860 }
1861
1862
1863 SWIGCLASS_STATIC int _wrap_debug_amindexd_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
1864   MAGIC_PPERL
1865   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_amindexd)))  ;
1866   return 1;
1867 }
1868
1869
1870 SWIGCLASS_STATIC int _wrap_debug_amrecover_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
1871   MAGIC_PPERL
1872   {
1873     int val;
1874     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
1875     if (!SWIG_IsOK(res)) {
1876       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_amrecover""' of type '""int""'");
1877     }
1878     debug_amrecover = (int)(val);
1879   }
1880 fail:
1881   return 1;
1882 }
1883
1884
1885 SWIGCLASS_STATIC int _wrap_debug_amrecover_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
1886   MAGIC_PPERL
1887   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_amrecover)))  ;
1888   return 1;
1889 }
1890
1891
1892 SWIGCLASS_STATIC int _wrap_debug_auth_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
1893   MAGIC_PPERL
1894   {
1895     int val;
1896     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
1897     if (!SWIG_IsOK(res)) {
1898       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_auth""' of type '""int""'");
1899     }
1900     debug_auth = (int)(val);
1901   }
1902 fail:
1903   return 1;
1904 }
1905
1906
1907 SWIGCLASS_STATIC int _wrap_debug_auth_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
1908   MAGIC_PPERL
1909   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_auth)))  ;
1910   return 1;
1911 }
1912
1913
1914 SWIGCLASS_STATIC int _wrap_debug_event_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
1915   MAGIC_PPERL
1916   {
1917     int val;
1918     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
1919     if (!SWIG_IsOK(res)) {
1920       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_event""' of type '""int""'");
1921     }
1922     debug_event = (int)(val);
1923   }
1924 fail:
1925   return 1;
1926 }
1927
1928
1929 SWIGCLASS_STATIC int _wrap_debug_event_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
1930   MAGIC_PPERL
1931   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_event)))  ;
1932   return 1;
1933 }
1934
1935
1936 SWIGCLASS_STATIC int _wrap_debug_holding_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
1937   MAGIC_PPERL
1938   {
1939     int val;
1940     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
1941     if (!SWIG_IsOK(res)) {
1942       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_holding""' of type '""int""'");
1943     }
1944     debug_holding = (int)(val);
1945   }
1946 fail:
1947   return 1;
1948 }
1949
1950
1951 SWIGCLASS_STATIC int _wrap_debug_holding_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
1952   MAGIC_PPERL
1953   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_holding)))  ;
1954   return 1;
1955 }
1956
1957
1958 SWIGCLASS_STATIC int _wrap_debug_protocol_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
1959   MAGIC_PPERL
1960   {
1961     int val;
1962     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
1963     if (!SWIG_IsOK(res)) {
1964       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_protocol""' of type '""int""'");
1965     }
1966     debug_protocol = (int)(val);
1967   }
1968 fail:
1969   return 1;
1970 }
1971
1972
1973 SWIGCLASS_STATIC int _wrap_debug_protocol_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
1974   MAGIC_PPERL
1975   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_protocol)))  ;
1976   return 1;
1977 }
1978
1979
1980 SWIGCLASS_STATIC int _wrap_debug_planner_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
1981   MAGIC_PPERL
1982   {
1983     int val;
1984     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
1985     if (!SWIG_IsOK(res)) {
1986       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_planner""' of type '""int""'");
1987     }
1988     debug_planner = (int)(val);
1989   }
1990 fail:
1991   return 1;
1992 }
1993
1994
1995 SWIGCLASS_STATIC int _wrap_debug_planner_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
1996   MAGIC_PPERL
1997   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_planner)))  ;
1998   return 1;
1999 }
2000
2001
2002 SWIGCLASS_STATIC int _wrap_debug_driver_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2003   MAGIC_PPERL
2004   {
2005     int val;
2006     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
2007     if (!SWIG_IsOK(res)) {
2008       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_driver""' of type '""int""'");
2009     }
2010     debug_driver = (int)(val);
2011   }
2012 fail:
2013   return 1;
2014 }
2015
2016
2017 SWIGCLASS_STATIC int _wrap_debug_driver_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2018   MAGIC_PPERL
2019   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_driver)))  ;
2020   return 1;
2021 }
2022
2023
2024 SWIGCLASS_STATIC int _wrap_debug_dumper_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2025   MAGIC_PPERL
2026   {
2027     int val;
2028     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
2029     if (!SWIG_IsOK(res)) {
2030       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_dumper""' of type '""int""'");
2031     }
2032     debug_dumper = (int)(val);
2033   }
2034 fail:
2035   return 1;
2036 }
2037
2038
2039 SWIGCLASS_STATIC int _wrap_debug_dumper_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2040   MAGIC_PPERL
2041   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_dumper)))  ;
2042   return 1;
2043 }
2044
2045
2046 SWIGCLASS_STATIC int _wrap_debug_chunker_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2047   MAGIC_PPERL
2048   {
2049     int val;
2050     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
2051     if (!SWIG_IsOK(res)) {
2052       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_chunker""' of type '""int""'");
2053     }
2054     debug_chunker = (int)(val);
2055   }
2056 fail:
2057   return 1;
2058 }
2059
2060
2061 SWIGCLASS_STATIC int _wrap_debug_chunker_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2062   MAGIC_PPERL
2063   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_chunker)))  ;
2064   return 1;
2065 }
2066
2067
2068 SWIGCLASS_STATIC int _wrap_debug_taper_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2069   MAGIC_PPERL
2070   {
2071     int val;
2072     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
2073     if (!SWIG_IsOK(res)) {
2074       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_taper""' of type '""int""'");
2075     }
2076     debug_taper = (int)(val);
2077   }
2078 fail:
2079   return 1;
2080 }
2081
2082
2083 SWIGCLASS_STATIC int _wrap_debug_taper_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2084   MAGIC_PPERL
2085   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_taper)))  ;
2086   return 1;
2087 }
2088
2089
2090 SWIGCLASS_STATIC int _wrap_debug_selfcheck_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2091   MAGIC_PPERL
2092   {
2093     int val;
2094     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
2095     if (!SWIG_IsOK(res)) {
2096       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_selfcheck""' of type '""int""'");
2097     }
2098     debug_selfcheck = (int)(val);
2099   }
2100 fail:
2101   return 1;
2102 }
2103
2104
2105 SWIGCLASS_STATIC int _wrap_debug_selfcheck_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2106   MAGIC_PPERL
2107   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_selfcheck)))  ;
2108   return 1;
2109 }
2110
2111
2112 SWIGCLASS_STATIC int _wrap_debug_sendsize_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2113   MAGIC_PPERL
2114   {
2115     int val;
2116     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
2117     if (!SWIG_IsOK(res)) {
2118       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_sendsize""' of type '""int""'");
2119     }
2120     debug_sendsize = (int)(val);
2121   }
2122 fail:
2123   return 1;
2124 }
2125
2126
2127 SWIGCLASS_STATIC int _wrap_debug_sendsize_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2128   MAGIC_PPERL
2129   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_sendsize)))  ;
2130   return 1;
2131 }
2132
2133
2134 SWIGCLASS_STATIC int _wrap_debug_sendbackup_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
2135   MAGIC_PPERL
2136   {
2137     int val;
2138     int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
2139     if (!SWIG_IsOK(res)) {
2140       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_sendbackup""' of type '""int""'");
2141     }
2142     debug_sendbackup = (int)(val);
2143   }
2144 fail:
2145   return 1;
2146 }
2147
2148
2149 SWIGCLASS_STATIC int _wrap_debug_sendbackup_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
2150   MAGIC_PPERL
2151   sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_sendbackup)))  ;
2152   return 1;
2153 }
2154
2155
2156
2157
2158 #ifdef PERL_OBJECT
2159 };
2160 #endif
2161
2162 #ifdef __cplusplus
2163 }
2164 #endif
2165
2166 #ifdef __cplusplus
2167 extern "C" {
2168 #endif
2169 XS(_wrap_data_path_from_string) {
2170   {
2171     char *arg1 = (char *) 0 ;
2172     int res1 ;
2173     char *buf1 = 0 ;
2174     int alloc1 = 0 ;
2175     int argvi = 0;
2176     data_path_t result;
2177     dXSARGS;
2178
2179     if ((items < 1) || (items > 1)) {
2180       SWIG_croak("Usage: data_path_from_string(data);");
2181     }
2182     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2183     if (!SWIG_IsOK(res1)) {
2184       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "data_path_from_string" "', argument " "1"" of type '" "char *""'");
2185     }
2186     arg1 = (char *)(buf1);
2187     result = (data_path_t)data_path_from_string(arg1);
2188     {
2189       SV *for_stack;
2190       SP += argvi; PUTBACK;
2191       for_stack = sv_2mortal(amglue_newSVi64(result));
2192       SPAGAIN; SP -= argvi;
2193       ST(argvi) = for_stack;
2194       argvi++;
2195     }
2196     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2197     XSRETURN(argvi);
2198   fail:
2199     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2200     SWIG_croak_null();
2201   }
2202 }
2203
2204
2205 XS(_wrap_getconf) {
2206   {
2207     confparm_key arg1 ;
2208     int argvi = 0;
2209     val_t *result = 0 ;
2210     dXSARGS;
2211
2212     if ((items < 1) || (items > 1)) {
2213       SWIG_croak("Usage: getconf(key);");
2214     }
2215     {
2216       if (sizeof(signed int) == 1) {
2217         arg1 = amglue_SvI8(ST(0));
2218       } else if (sizeof(signed int) == 2) {
2219         arg1 = amglue_SvI16(ST(0));
2220       } else if (sizeof(signed int) == 4) {
2221         arg1 = amglue_SvI32(ST(0));
2222       } else if (sizeof(signed int) == 8) {
2223         arg1 = amglue_SvI64(ST(0));
2224       } else {
2225         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2226       }
2227     }
2228     result = (val_t *)getconf(arg1);
2229     {
2230       if (!result) {
2231         ST(argvi) = &PL_sv_undef;
2232         argvi++;
2233       } else {
2234         switch (result->type) {
2235           case CONFTYPE_RATE: {
2236             ST(argvi)= sv_newmortal();
2237             sv_setnv(ST(argvi), val_t__rate(result)[0]);
2238             argvi++;
2239
2240             ST(argvi)= sv_newmortal();
2241             sv_setnv(ST(argvi), val_t__rate(result)[1]);
2242             argvi++;
2243             break;
2244           }
2245
2246           case CONFTYPE_INTRANGE: {
2247             ST(argvi)= sv_newmortal();
2248             sv_setiv(ST(argvi), val_t__intrange(result)[0]);
2249             argvi++;
2250
2251             ST(argvi)= sv_newmortal();
2252             sv_setiv(ST(argvi), val_t__intrange(result)[1]);
2253             argvi++;
2254             break;
2255           }
2256
2257           case CONFTYPE_EXINCLUDE: {
2258             /* exincludes are represented in perl as {
2259                          *      'list' : [ 'list1', 'list2', ..],
2260                          *      'file' : [ 'file1', 'file2', ..],
2261                          *      'optional' : 1,
2262                          * }
2263                          */
2264             exinclude_t *ei = &val_t__exinclude(result);
2265             AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
2266             AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
2267             SV *optional = sv_newmortal();
2268             HV *hv;
2269             sle_t *iter;
2270
2271             /* first set up each of the hash values */
2272
2273             if (ei->sl_list) {
2274               for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
2275                 av_push(list_entries, newSVpv(iter->name, 0));
2276               }
2277             }
2278
2279             if(ei->sl_file) {
2280               for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
2281                 av_push(file_entries, newSVpv(iter->name, 0));
2282               }
2283             }
2284
2285             sv_setiv(optional, ei->optional);
2286
2287             /* now build the hash */
2288             hv = (HV *)sv_2mortal((SV *)newHV());
2289
2290             hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
2291             hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
2292             hv_store(hv, "optional", 8, optional, 0);
2293             SvREFCNT_inc(optional);
2294
2295             ST(argvi) = sv_2mortal(newRV((SV *)hv));
2296             argvi++;
2297             break;
2298           }
2299
2300         case CONFTYPE_PROPLIST:
2301           ST(argvi) = sv_2mortal(g_hash_table_to_hashref_property(val_t__proplist(result)));
2302           argvi++;
2303           break;
2304
2305         case CONFTYPE_SIZE:
2306           SP += argvi; PUTBACK;
2307           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
2308           SPAGAIN; SP -= argvi; argvi++;
2309           break;
2310
2311         case CONFTYPE_INT64:
2312           SP += argvi; PUTBACK;
2313           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int64(result)));
2314           SPAGAIN; SP -= argvi; argvi++;
2315           break;
2316
2317           case CONFTYPE_BOOLEAN:            /* all same as INT.. */
2318         case CONFTYPE_COMPRESS:
2319         case CONFTYPE_ENCRYPT:
2320         case CONFTYPE_STRATEGY:
2321         case CONFTYPE_TAPERALGO:
2322         case CONFTYPE_PRIORITY:
2323         case CONFTYPE_HOLDING:
2324         case CONFTYPE_EXECUTE_ON:
2325         case CONFTYPE_EXECUTE_WHERE:
2326         case CONFTYPE_SEND_AMREPORT_ON:
2327         case CONFTYPE_DATA_PATH:
2328         case CONFTYPE_INT:
2329           SP += argvi; PUTBACK;
2330           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
2331           SPAGAIN; SP -= argvi; argvi++;
2332           break;
2333
2334           case CONFTYPE_ESTIMATELIST: {
2335             AV *elist = newAV();
2336             estimatelist_t el;
2337             for (el=val_t__estimatelist(result); el != NULL; el = el->next) {
2338               av_push(elist, newSVuv(GPOINTER_TO_INT(el->data)));
2339             }
2340             ST(argvi) = sv_2mortal(newRV_noinc((SV *)elist));
2341             argvi++;
2342             break;
2343           }
2344
2345         case CONFTYPE_TIME:
2346           SP += argvi; PUTBACK;
2347           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
2348           SPAGAIN; SP -= argvi; argvi++;
2349           break;
2350
2351         case CONFTYPE_REAL:
2352           ST(argvi) = sv_newmortal();
2353           sv_setnv(ST(argvi), val_t__real(result));
2354           argvi++;
2355           break;
2356
2357           case CONFTYPE_IDENT:      /* same as STRING */
2358         case CONFTYPE_STR:
2359         case CONFTYPE_APPLICATION:
2360           ST(argvi) = sv_newmortal();
2361           sv_setpv(ST(argvi), val_t__str(result));
2362           argvi++;
2363           break;
2364
2365           case CONFTYPE_IDENTLIST: {
2366             AV *ilist = newAV();
2367
2368             identlist_t il;
2369             for (il=val_t__identlist(result); il != NULL; il = il->next) {
2370               av_push(ilist, newSVpv((char *)il->data, 0));
2371             }
2372
2373             ST(argvi) = sv_2mortal(newRV_noinc((SV *)ilist));
2374             argvi++;
2375             break;
2376           }
2377
2378           case CONFTYPE_AUTOLABEL: {
2379             autolabel_t *autolabel = &val_t__autolabel(result);
2380             HV *hv;
2381
2382             /* now build the hash */
2383             hv = (HV *)sv_2mortal((SV *)newHV());
2384             hv_store(hv, "template", 8,
2385               (autolabel->template)? newSVpv(autolabel->template, 0) : newSV(0),
2386               0);
2387             hv_store(hv, "other_config", 12,
2388               (autolabel->autolabel & AL_OTHER_CONFIG)? &PL_sv_yes : &PL_sv_no,
2389               0);
2390             hv_store(hv, "non_amanda", 10,
2391               (autolabel->autolabel & AL_NON_AMANDA)? &PL_sv_yes : &PL_sv_no,
2392               0);
2393             hv_store(hv, "volume_error", 12,
2394               (autolabel->autolabel & AL_VOLUME_ERROR)? &PL_sv_yes : &PL_sv_no,
2395               0);
2396             hv_store(hv, "empty", 5,
2397               (autolabel->autolabel & AL_EMPTY)? &PL_sv_yes : &PL_sv_no,
2398               0);
2399
2400             ST(argvi) = sv_2mortal(newRV((SV *)hv));
2401             argvi++;
2402             break;
2403           }
2404
2405           /* No match yet -> not one of the "complex" types */
2406         default:
2407           SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
2408           break;
2409         }
2410       }
2411     }
2412
2413     XSRETURN(argvi);
2414   fail:
2415
2416     SWIG_croak_null();
2417   }
2418 }
2419
2420
2421 XS(_wrap_getconf_seen) {
2422   {
2423     confparm_key arg1 ;
2424     int argvi = 0;
2425     gboolean result;
2426     dXSARGS;
2427
2428     if ((items < 1) || (items > 1)) {
2429       SWIG_croak("Usage: getconf_seen(key);");
2430     }
2431     {
2432       if (sizeof(signed int) == 1) {
2433         arg1 = amglue_SvI8(ST(0));
2434       } else if (sizeof(signed int) == 2) {
2435         arg1 = amglue_SvI16(ST(0));
2436       } else if (sizeof(signed int) == 4) {
2437         arg1 = amglue_SvI32(ST(0));
2438       } else if (sizeof(signed int) == 8) {
2439         arg1 = amglue_SvI64(ST(0));
2440       } else {
2441         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2442       }
2443     }
2444     result = (gboolean)getconf_seen(arg1);
2445     {
2446       if (result)
2447       ST(argvi) = &PL_sv_yes;
2448       else
2449       ST(argvi) = &PL_sv_no;
2450       argvi++;
2451     }
2452
2453     XSRETURN(argvi);
2454   fail:
2455
2456     SWIG_croak_null();
2457   }
2458 }
2459
2460
2461 XS(_wrap_getconf_linenum) {
2462   {
2463     confparm_key arg1 ;
2464     int argvi = 0;
2465     int result;
2466     dXSARGS;
2467
2468     if ((items < 1) || (items > 1)) {
2469       SWIG_croak("Usage: getconf_linenum(key);");
2470     }
2471     {
2472       if (sizeof(signed int) == 1) {
2473         arg1 = amglue_SvI8(ST(0));
2474       } else if (sizeof(signed int) == 2) {
2475         arg1 = amglue_SvI16(ST(0));
2476       } else if (sizeof(signed int) == 4) {
2477         arg1 = amglue_SvI32(ST(0));
2478       } else if (sizeof(signed int) == 8) {
2479         arg1 = amglue_SvI64(ST(0));
2480       } else {
2481         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2482       }
2483     }
2484     result = (int)getconf_linenum(arg1);
2485     {
2486       SV *for_stack;
2487       SP += argvi; PUTBACK;
2488       for_stack = sv_2mortal(amglue_newSVi64(result));
2489       SPAGAIN; SP -= argvi;
2490       ST(argvi) = for_stack;
2491       argvi++;
2492     }
2493
2494     XSRETURN(argvi);
2495   fail:
2496
2497     SWIG_croak_null();
2498   }
2499 }
2500
2501
2502 XS(_wrap_getconf_byname) {
2503   {
2504     char *arg1 = (char *) 0 ;
2505     int res1 ;
2506     char *buf1 = 0 ;
2507     int alloc1 = 0 ;
2508     int argvi = 0;
2509     val_t *result = 0 ;
2510     dXSARGS;
2511
2512     if ((items < 1) || (items > 1)) {
2513       SWIG_croak("Usage: getconf_byname(key);");
2514     }
2515     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2516     if (!SWIG_IsOK(res1)) {
2517       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getconf_byname" "', argument " "1"" of type '" "char *""'");
2518     }
2519     arg1 = (char *)(buf1);
2520     result = (val_t *)getconf_byname(arg1);
2521     {
2522       if (!result) {
2523         ST(argvi) = &PL_sv_undef;
2524         argvi++;
2525       } else {
2526         switch (result->type) {
2527           case CONFTYPE_RATE: {
2528             ST(argvi)= sv_newmortal();
2529             sv_setnv(ST(argvi), val_t__rate(result)[0]);
2530             argvi++;
2531
2532             ST(argvi)= sv_newmortal();
2533             sv_setnv(ST(argvi), val_t__rate(result)[1]);
2534             argvi++;
2535             break;
2536           }
2537
2538           case CONFTYPE_INTRANGE: {
2539             ST(argvi)= sv_newmortal();
2540             sv_setiv(ST(argvi), val_t__intrange(result)[0]);
2541             argvi++;
2542
2543             ST(argvi)= sv_newmortal();
2544             sv_setiv(ST(argvi), val_t__intrange(result)[1]);
2545             argvi++;
2546             break;
2547           }
2548
2549           case CONFTYPE_EXINCLUDE: {
2550             /* exincludes are represented in perl as {
2551                          *      'list' : [ 'list1', 'list2', ..],
2552                          *      'file' : [ 'file1', 'file2', ..],
2553                          *      'optional' : 1,
2554                          * }
2555                          */
2556             exinclude_t *ei = &val_t__exinclude(result);
2557             AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
2558             AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
2559             SV *optional = sv_newmortal();
2560             HV *hv;
2561             sle_t *iter;
2562
2563             /* first set up each of the hash values */
2564
2565             if (ei->sl_list) {
2566               for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
2567                 av_push(list_entries, newSVpv(iter->name, 0));
2568               }
2569             }
2570
2571             if(ei->sl_file) {
2572               for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
2573                 av_push(file_entries, newSVpv(iter->name, 0));
2574               }
2575             }
2576
2577             sv_setiv(optional, ei->optional);
2578
2579             /* now build the hash */
2580             hv = (HV *)sv_2mortal((SV *)newHV());
2581
2582             hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
2583             hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
2584             hv_store(hv, "optional", 8, optional, 0);
2585             SvREFCNT_inc(optional);
2586
2587             ST(argvi) = sv_2mortal(newRV((SV *)hv));
2588             argvi++;
2589             break;
2590           }
2591
2592         case CONFTYPE_PROPLIST:
2593           ST(argvi) = sv_2mortal(g_hash_table_to_hashref_property(val_t__proplist(result)));
2594           argvi++;
2595           break;
2596
2597         case CONFTYPE_SIZE:
2598           SP += argvi; PUTBACK;
2599           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
2600           SPAGAIN; SP -= argvi; argvi++;
2601           break;
2602
2603         case CONFTYPE_INT64:
2604           SP += argvi; PUTBACK;
2605           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int64(result)));
2606           SPAGAIN; SP -= argvi; argvi++;
2607           break;
2608
2609           case CONFTYPE_BOOLEAN:            /* all same as INT.. */
2610         case CONFTYPE_COMPRESS:
2611         case CONFTYPE_ENCRYPT:
2612         case CONFTYPE_STRATEGY:
2613         case CONFTYPE_TAPERALGO:
2614         case CONFTYPE_PRIORITY:
2615         case CONFTYPE_HOLDING:
2616         case CONFTYPE_EXECUTE_ON:
2617         case CONFTYPE_EXECUTE_WHERE:
2618         case CONFTYPE_SEND_AMREPORT_ON:
2619         case CONFTYPE_DATA_PATH:
2620         case CONFTYPE_INT:
2621           SP += argvi; PUTBACK;
2622           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
2623           SPAGAIN; SP -= argvi; argvi++;
2624           break;
2625
2626           case CONFTYPE_ESTIMATELIST: {
2627             AV *elist = newAV();
2628             estimatelist_t el;
2629             for (el=val_t__estimatelist(result); el != NULL; el = el->next) {
2630               av_push(elist, newSVuv(GPOINTER_TO_INT(el->data)));
2631             }
2632             ST(argvi) = sv_2mortal(newRV_noinc((SV *)elist));
2633             argvi++;
2634             break;
2635           }
2636
2637         case CONFTYPE_TIME:
2638           SP += argvi; PUTBACK;
2639           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
2640           SPAGAIN; SP -= argvi; argvi++;
2641           break;
2642
2643         case CONFTYPE_REAL:
2644           ST(argvi) = sv_newmortal();
2645           sv_setnv(ST(argvi), val_t__real(result));
2646           argvi++;
2647           break;
2648
2649           case CONFTYPE_IDENT:      /* same as STRING */
2650         case CONFTYPE_STR:
2651         case CONFTYPE_APPLICATION:
2652           ST(argvi) = sv_newmortal();
2653           sv_setpv(ST(argvi), val_t__str(result));
2654           argvi++;
2655           break;
2656
2657           case CONFTYPE_IDENTLIST: {
2658             AV *ilist = newAV();
2659
2660             identlist_t il;
2661             for (il=val_t__identlist(result); il != NULL; il = il->next) {
2662               av_push(ilist, newSVpv((char *)il->data, 0));
2663             }
2664
2665             ST(argvi) = sv_2mortal(newRV_noinc((SV *)ilist));
2666             argvi++;
2667             break;
2668           }
2669
2670           case CONFTYPE_AUTOLABEL: {
2671             autolabel_t *autolabel = &val_t__autolabel(result);
2672             HV *hv;
2673
2674             /* now build the hash */
2675             hv = (HV *)sv_2mortal((SV *)newHV());
2676             hv_store(hv, "template", 8,
2677               (autolabel->template)? newSVpv(autolabel->template, 0) : newSV(0),
2678               0);
2679             hv_store(hv, "other_config", 12,
2680               (autolabel->autolabel & AL_OTHER_CONFIG)? &PL_sv_yes : &PL_sv_no,
2681               0);
2682             hv_store(hv, "non_amanda", 10,
2683               (autolabel->autolabel & AL_NON_AMANDA)? &PL_sv_yes : &PL_sv_no,
2684               0);
2685             hv_store(hv, "volume_error", 12,
2686               (autolabel->autolabel & AL_VOLUME_ERROR)? &PL_sv_yes : &PL_sv_no,
2687               0);
2688             hv_store(hv, "empty", 5,
2689               (autolabel->autolabel & AL_EMPTY)? &PL_sv_yes : &PL_sv_no,
2690               0);
2691
2692             ST(argvi) = sv_2mortal(newRV((SV *)hv));
2693             argvi++;
2694             break;
2695           }
2696
2697           /* No match yet -> not one of the "complex" types */
2698         default:
2699           SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
2700           break;
2701         }
2702       }
2703     }
2704     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2705     XSRETURN(argvi);
2706   fail:
2707     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2708     SWIG_croak_null();
2709   }
2710 }
2711
2712
2713 XS(_wrap_getconf_list) {
2714   {
2715     char *arg1 = (char *) 0 ;
2716     int res1 ;
2717     char *buf1 = 0 ;
2718     int alloc1 = 0 ;
2719     int argvi = 0;
2720     GSList *result = 0 ;
2721     dXSARGS;
2722
2723     if ((items < 1) || (items > 1)) {
2724       SWIG_croak("Usage: getconf_list(listname);");
2725     }
2726     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2727     if (!SWIG_IsOK(res1)) {
2728       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getconf_list" "', argument " "1"" of type '" "char *""'");
2729     }
2730     arg1 = (char *)(buf1);
2731     result = (GSList *)getconf_list(arg1);
2732     {
2733       GSList *it = result;
2734
2735       while (it) {
2736         ST(argvi) = sv_2mortal(newSVpv(it->data, 0));
2737         argvi++;
2738         it = it->next;
2739       }
2740
2741       g_slist_free(result);
2742     }
2743     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2744     XSRETURN(argvi);
2745   fail:
2746     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2747     SWIG_croak_null();
2748   }
2749 }
2750
2751
2752 XS(_wrap_getconf_byname_strs) {
2753   {
2754     char *arg1 = (char *) 0 ;
2755     int arg2 ;
2756     int res1 ;
2757     char *buf1 = 0 ;
2758     int alloc1 = 0 ;
2759     int argvi = 0;
2760     val_t_strs result;
2761     dXSARGS;
2762
2763     if ((items < 2) || (items > 2)) {
2764       SWIG_croak("Usage: getconf_byname_strs(key,str_needs_quotes);");
2765     }
2766     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2767     if (!SWIG_IsOK(res1)) {
2768       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getconf_byname_strs" "', argument " "1"" of type '" "char *""'");
2769     }
2770     arg1 = (char *)(buf1);
2771     {
2772       if (sizeof(signed int) == 1) {
2773         arg2 = amglue_SvI8(ST(1));
2774       } else if (sizeof(signed int) == 2) {
2775         arg2 = amglue_SvI16(ST(1));
2776       } else if (sizeof(signed int) == 4) {
2777         arg2 = amglue_SvI32(ST(1));
2778       } else if (sizeof(signed int) == 8) {
2779         arg2 = amglue_SvI64(ST(1));
2780       } else {
2781         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2782       }
2783     }
2784     result = (val_t_strs)getconf_byname_strs(arg1,arg2);
2785     {
2786       char **it = result;
2787
2788       while (it && *it) {
2789         ST(argvi) = sv_2mortal(newSVpv(*it, 0));
2790         argvi++;
2791         it++;
2792       }
2793       g_strfreev(result);
2794     }
2795     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2796
2797     XSRETURN(argvi);
2798   fail:
2799     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2800
2801     SWIG_croak_null();
2802   }
2803 }
2804
2805
2806 XS(_wrap_lookup_tapetype) {
2807   {
2808     char *arg1 = (char *) 0 ;
2809     int res1 ;
2810     char *buf1 = 0 ;
2811     int alloc1 = 0 ;
2812     int argvi = 0;
2813     tapetype_t *result = 0 ;
2814     dXSARGS;
2815
2816     if ((items < 1) || (items > 1)) {
2817       SWIG_croak("Usage: lookup_tapetype(identifier);");
2818     }
2819     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2820     if (!SWIG_IsOK(res1)) {
2821       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lookup_tapetype" "', argument " "1"" of type '" "char *""'");
2822     }
2823     arg1 = (char *)(buf1);
2824     result = (tapetype_t *)lookup_tapetype(arg1);
2825     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tapetype_t, 0 | 0); argvi++ ;
2826     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2827     XSRETURN(argvi);
2828   fail:
2829     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2830     SWIG_croak_null();
2831   }
2832 }
2833
2834
2835 XS(_wrap_tapetype_getconf) {
2836   {
2837     tapetype_t *arg1 = (tapetype_t *) 0 ;
2838     tapetype_key arg2 ;
2839     void *argp1 = 0 ;
2840     int res1 = 0 ;
2841     int argvi = 0;
2842     val_t *result = 0 ;
2843     dXSARGS;
2844
2845     if ((items < 2) || (items > 2)) {
2846       SWIG_croak("Usage: tapetype_getconf(ttyp,key);");
2847     }
2848     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_tapetype_t, 0 |  0 );
2849     if (!SWIG_IsOK(res1)) {
2850       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tapetype_getconf" "', argument " "1"" of type '" "tapetype_t *""'");
2851     }
2852     arg1 = (tapetype_t *)(argp1);
2853     {
2854       if (sizeof(signed int) == 1) {
2855         arg2 = amglue_SvI8(ST(1));
2856       } else if (sizeof(signed int) == 2) {
2857         arg2 = amglue_SvI16(ST(1));
2858       } else if (sizeof(signed int) == 4) {
2859         arg2 = amglue_SvI32(ST(1));
2860       } else if (sizeof(signed int) == 8) {
2861         arg2 = amglue_SvI64(ST(1));
2862       } else {
2863         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2864       }
2865     }
2866     result = (val_t *)tapetype_getconf(arg1,arg2);
2867     {
2868       if (!result) {
2869         ST(argvi) = &PL_sv_undef;
2870         argvi++;
2871       } else {
2872         switch (result->type) {
2873           case CONFTYPE_RATE: {
2874             ST(argvi)= sv_newmortal();
2875             sv_setnv(ST(argvi), val_t__rate(result)[0]);
2876             argvi++;
2877
2878             ST(argvi)= sv_newmortal();
2879             sv_setnv(ST(argvi), val_t__rate(result)[1]);
2880             argvi++;
2881             break;
2882           }
2883
2884           case CONFTYPE_INTRANGE: {
2885             ST(argvi)= sv_newmortal();
2886             sv_setiv(ST(argvi), val_t__intrange(result)[0]);
2887             argvi++;
2888
2889             ST(argvi)= sv_newmortal();
2890             sv_setiv(ST(argvi), val_t__intrange(result)[1]);
2891             argvi++;
2892             break;
2893           }
2894
2895           case CONFTYPE_EXINCLUDE: {
2896             /* exincludes are represented in perl as {
2897                          *      'list' : [ 'list1', 'list2', ..],
2898                          *      'file' : [ 'file1', 'file2', ..],
2899                          *      'optional' : 1,
2900                          * }
2901                          */
2902             exinclude_t *ei = &val_t__exinclude(result);
2903             AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
2904             AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
2905             SV *optional = sv_newmortal();
2906             HV *hv;
2907             sle_t *iter;
2908
2909             /* first set up each of the hash values */
2910
2911             if (ei->sl_list) {
2912               for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
2913                 av_push(list_entries, newSVpv(iter->name, 0));
2914               }
2915             }
2916
2917             if(ei->sl_file) {
2918               for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
2919                 av_push(file_entries, newSVpv(iter->name, 0));
2920               }
2921             }
2922
2923             sv_setiv(optional, ei->optional);
2924
2925             /* now build the hash */
2926             hv = (HV *)sv_2mortal((SV *)newHV());
2927
2928             hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
2929             hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
2930             hv_store(hv, "optional", 8, optional, 0);
2931             SvREFCNT_inc(optional);
2932
2933             ST(argvi) = sv_2mortal(newRV((SV *)hv));
2934             argvi++;
2935             break;
2936           }
2937
2938         case CONFTYPE_PROPLIST:
2939           ST(argvi) = sv_2mortal(g_hash_table_to_hashref_property(val_t__proplist(result)));
2940           argvi++;
2941           break;
2942
2943         case CONFTYPE_SIZE:
2944           SP += argvi; PUTBACK;
2945           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
2946           SPAGAIN; SP -= argvi; argvi++;
2947           break;
2948
2949         case CONFTYPE_INT64:
2950           SP += argvi; PUTBACK;
2951           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int64(result)));
2952           SPAGAIN; SP -= argvi; argvi++;
2953           break;
2954
2955           case CONFTYPE_BOOLEAN:            /* all same as INT.. */
2956         case CONFTYPE_COMPRESS:
2957         case CONFTYPE_ENCRYPT:
2958         case CONFTYPE_STRATEGY:
2959         case CONFTYPE_TAPERALGO:
2960         case CONFTYPE_PRIORITY:
2961         case CONFTYPE_HOLDING:
2962         case CONFTYPE_EXECUTE_ON:
2963         case CONFTYPE_EXECUTE_WHERE:
2964         case CONFTYPE_SEND_AMREPORT_ON:
2965         case CONFTYPE_DATA_PATH:
2966         case CONFTYPE_INT:
2967           SP += argvi; PUTBACK;
2968           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
2969           SPAGAIN; SP -= argvi; argvi++;
2970           break;
2971
2972           case CONFTYPE_ESTIMATELIST: {
2973             AV *elist = newAV();
2974             estimatelist_t el;
2975             for (el=val_t__estimatelist(result); el != NULL; el = el->next) {
2976               av_push(elist, newSVuv(GPOINTER_TO_INT(el->data)));
2977             }
2978             ST(argvi) = sv_2mortal(newRV_noinc((SV *)elist));
2979             argvi++;
2980             break;
2981           }
2982
2983         case CONFTYPE_TIME:
2984           SP += argvi; PUTBACK;
2985           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
2986           SPAGAIN; SP -= argvi; argvi++;
2987           break;
2988
2989         case CONFTYPE_REAL:
2990           ST(argvi) = sv_newmortal();
2991           sv_setnv(ST(argvi), val_t__real(result));
2992           argvi++;
2993           break;
2994
2995           case CONFTYPE_IDENT:      /* same as STRING */
2996         case CONFTYPE_STR:
2997         case CONFTYPE_APPLICATION:
2998           ST(argvi) = sv_newmortal();
2999           sv_setpv(ST(argvi), val_t__str(result));
3000           argvi++;
3001           break;
3002
3003           case CONFTYPE_IDENTLIST: {
3004             AV *ilist = newAV();
3005
3006             identlist_t il;
3007             for (il=val_t__identlist(result); il != NULL; il = il->next) {
3008               av_push(ilist, newSVpv((char *)il->data, 0));
3009             }
3010
3011             ST(argvi) = sv_2mortal(newRV_noinc((SV *)ilist));
3012             argvi++;
3013             break;
3014           }
3015
3016           case CONFTYPE_AUTOLABEL: {
3017             autolabel_t *autolabel = &val_t__autolabel(result);
3018             HV *hv;
3019
3020             /* now build the hash */
3021             hv = (HV *)sv_2mortal((SV *)newHV());
3022             hv_store(hv, "template", 8,
3023               (autolabel->template)? newSVpv(autolabel->template, 0) : newSV(0),
3024               0);
3025             hv_store(hv, "other_config", 12,
3026               (autolabel->autolabel & AL_OTHER_CONFIG)? &PL_sv_yes : &PL_sv_no,
3027               0);
3028             hv_store(hv, "non_amanda", 10,
3029               (autolabel->autolabel & AL_NON_AMANDA)? &PL_sv_yes : &PL_sv_no,
3030               0);
3031             hv_store(hv, "volume_error", 12,
3032               (autolabel->autolabel & AL_VOLUME_ERROR)? &PL_sv_yes : &PL_sv_no,
3033               0);
3034             hv_store(hv, "empty", 5,
3035               (autolabel->autolabel & AL_EMPTY)? &PL_sv_yes : &PL_sv_no,
3036               0);
3037
3038             ST(argvi) = sv_2mortal(newRV((SV *)hv));
3039             argvi++;
3040             break;
3041           }
3042
3043           /* No match yet -> not one of the "complex" types */
3044         default:
3045           SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
3046           break;
3047         }
3048       }
3049     }
3050
3051
3052     XSRETURN(argvi);
3053   fail:
3054
3055
3056     SWIG_croak_null();
3057   }
3058 }
3059
3060
3061 XS(_wrap_tapetype_name) {
3062   {
3063     tapetype_t *arg1 = (tapetype_t *) 0 ;
3064     void *argp1 = 0 ;
3065     int res1 = 0 ;
3066     int argvi = 0;
3067     char *result = 0 ;
3068     dXSARGS;
3069
3070     if ((items < 1) || (items > 1)) {
3071       SWIG_croak("Usage: tapetype_name(ttyp);");
3072     }
3073     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_tapetype_t, 0 |  0 );
3074     if (!SWIG_IsOK(res1)) {
3075       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tapetype_name" "', argument " "1"" of type '" "tapetype_t *""'");
3076     }
3077     arg1 = (tapetype_t *)(argp1);
3078     result = (char *)tapetype_name(arg1);
3079     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3080
3081     XSRETURN(argvi);
3082   fail:
3083
3084     SWIG_croak_null();
3085   }
3086 }
3087
3088
3089 XS(_wrap_tapetype_seen) {
3090   {
3091     tapetype_t *arg1 = (tapetype_t *) 0 ;
3092     tapetype_key arg2 ;
3093     void *argp1 = 0 ;
3094     int res1 = 0 ;
3095     int argvi = 0;
3096     gboolean result;
3097     dXSARGS;
3098
3099     if ((items < 2) || (items > 2)) {
3100       SWIG_croak("Usage: tapetype_seen(ttyp,key);");
3101     }
3102     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_tapetype_t, 0 |  0 );
3103     if (!SWIG_IsOK(res1)) {
3104       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tapetype_seen" "', argument " "1"" of type '" "tapetype_t *""'");
3105     }
3106     arg1 = (tapetype_t *)(argp1);
3107     {
3108       if (sizeof(signed int) == 1) {
3109         arg2 = amglue_SvI8(ST(1));
3110       } else if (sizeof(signed int) == 2) {
3111         arg2 = amglue_SvI16(ST(1));
3112       } else if (sizeof(signed int) == 4) {
3113         arg2 = amglue_SvI32(ST(1));
3114       } else if (sizeof(signed int) == 8) {
3115         arg2 = amglue_SvI64(ST(1));
3116       } else {
3117         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3118       }
3119     }
3120     result = (gboolean)tapetype_seen(arg1,arg2);
3121     {
3122       if (result)
3123       ST(argvi) = &PL_sv_yes;
3124       else
3125       ST(argvi) = &PL_sv_no;
3126       argvi++;
3127     }
3128
3129
3130     XSRETURN(argvi);
3131   fail:
3132
3133
3134     SWIG_croak_null();
3135   }
3136 }
3137
3138
3139 XS(_wrap_lookup_dumptype) {
3140   {
3141     char *arg1 = (char *) 0 ;
3142     int res1 ;
3143     char *buf1 = 0 ;
3144     int alloc1 = 0 ;
3145     int argvi = 0;
3146     dumptype_t *result = 0 ;
3147     dXSARGS;
3148
3149     if ((items < 1) || (items > 1)) {
3150       SWIG_croak("Usage: lookup_dumptype(identifier);");
3151     }
3152     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
3153     if (!SWIG_IsOK(res1)) {
3154       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lookup_dumptype" "', argument " "1"" of type '" "char *""'");
3155     }
3156     arg1 = (char *)(buf1);
3157     result = (dumptype_t *)lookup_dumptype(arg1);
3158     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumptype_t, 0 | 0); argvi++ ;
3159     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3160     XSRETURN(argvi);
3161   fail:
3162     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3163     SWIG_croak_null();
3164   }
3165 }
3166
3167
3168 XS(_wrap_dumptype_getconf) {
3169   {
3170     dumptype_t *arg1 = (dumptype_t *) 0 ;
3171     dumptype_key arg2 ;
3172     void *argp1 = 0 ;
3173     int res1 = 0 ;
3174     int argvi = 0;
3175     val_t *result = 0 ;
3176     dXSARGS;
3177
3178     if ((items < 2) || (items > 2)) {
3179       SWIG_croak("Usage: dumptype_getconf(dtyp,key);");
3180     }
3181     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumptype_t, 0 |  0 );
3182     if (!SWIG_IsOK(res1)) {
3183       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumptype_getconf" "', argument " "1"" of type '" "dumptype_t *""'");
3184     }
3185     arg1 = (dumptype_t *)(argp1);
3186     {
3187       if (sizeof(signed int) == 1) {
3188         arg2 = amglue_SvI8(ST(1));
3189       } else if (sizeof(signed int) == 2) {
3190         arg2 = amglue_SvI16(ST(1));
3191       } else if (sizeof(signed int) == 4) {
3192         arg2 = amglue_SvI32(ST(1));
3193       } else if (sizeof(signed int) == 8) {
3194         arg2 = amglue_SvI64(ST(1));
3195       } else {
3196         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3197       }
3198     }
3199     result = (val_t *)dumptype_getconf(arg1,arg2);
3200     {
3201       if (!result) {
3202         ST(argvi) = &PL_sv_undef;
3203         argvi++;
3204       } else {
3205         switch (result->type) {
3206           case CONFTYPE_RATE: {
3207             ST(argvi)= sv_newmortal();
3208             sv_setnv(ST(argvi), val_t__rate(result)[0]);
3209             argvi++;
3210
3211             ST(argvi)= sv_newmortal();
3212             sv_setnv(ST(argvi), val_t__rate(result)[1]);
3213             argvi++;
3214             break;
3215           }
3216
3217           case CONFTYPE_INTRANGE: {
3218             ST(argvi)= sv_newmortal();
3219             sv_setiv(ST(argvi), val_t__intrange(result)[0]);
3220             argvi++;
3221
3222             ST(argvi)= sv_newmortal();
3223             sv_setiv(ST(argvi), val_t__intrange(result)[1]);
3224             argvi++;
3225             break;
3226           }
3227
3228           case CONFTYPE_EXINCLUDE: {
3229             /* exincludes are represented in perl as {
3230                          *      'list' : [ 'list1', 'list2', ..],
3231                          *      'file' : [ 'file1', 'file2', ..],
3232                          *      'optional' : 1,
3233                          * }
3234                          */
3235             exinclude_t *ei = &val_t__exinclude(result);
3236             AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
3237             AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
3238             SV *optional = sv_newmortal();
3239             HV *hv;
3240             sle_t *iter;
3241
3242             /* first set up each of the hash values */
3243
3244             if (ei->sl_list) {
3245               for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
3246                 av_push(list_entries, newSVpv(iter->name, 0));
3247               }
3248             }
3249
3250             if(ei->sl_file) {
3251               for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
3252                 av_push(file_entries, newSVpv(iter->name, 0));
3253               }
3254             }
3255
3256             sv_setiv(optional, ei->optional);
3257
3258             /* now build the hash */
3259             hv = (HV *)sv_2mortal((SV *)newHV());
3260
3261             hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
3262             hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
3263             hv_store(hv, "optional", 8, optional, 0);
3264             SvREFCNT_inc(optional);
3265
3266             ST(argvi) = sv_2mortal(newRV((SV *)hv));
3267             argvi++;
3268             break;
3269           }
3270
3271         case CONFTYPE_PROPLIST:
3272           ST(argvi) = sv_2mortal(g_hash_table_to_hashref_property(val_t__proplist(result)));
3273           argvi++;
3274           break;
3275
3276         case CONFTYPE_SIZE:
3277           SP += argvi; PUTBACK;
3278           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
3279           SPAGAIN; SP -= argvi; argvi++;
3280           break;
3281
3282         case CONFTYPE_INT64:
3283           SP += argvi; PUTBACK;
3284           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int64(result)));
3285           SPAGAIN; SP -= argvi; argvi++;
3286           break;
3287
3288           case CONFTYPE_BOOLEAN:            /* all same as INT.. */
3289         case CONFTYPE_COMPRESS:
3290         case CONFTYPE_ENCRYPT:
3291         case CONFTYPE_STRATEGY:
3292         case CONFTYPE_TAPERALGO:
3293         case CONFTYPE_PRIORITY:
3294         case CONFTYPE_HOLDING:
3295         case CONFTYPE_EXECUTE_ON:
3296         case CONFTYPE_EXECUTE_WHERE:
3297         case CONFTYPE_SEND_AMREPORT_ON:
3298         case CONFTYPE_DATA_PATH:
3299         case CONFTYPE_INT:
3300           SP += argvi; PUTBACK;
3301           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
3302           SPAGAIN; SP -= argvi; argvi++;
3303           break;
3304
3305           case CONFTYPE_ESTIMATELIST: {
3306             AV *elist = newAV();
3307             estimatelist_t el;
3308             for (el=val_t__estimatelist(result); el != NULL; el = el->next) {
3309               av_push(elist, newSVuv(GPOINTER_TO_INT(el->data)));
3310             }
3311             ST(argvi) = sv_2mortal(newRV_noinc((SV *)elist));
3312             argvi++;
3313             break;
3314           }
3315
3316         case CONFTYPE_TIME:
3317           SP += argvi; PUTBACK;
3318           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
3319           SPAGAIN; SP -= argvi; argvi++;
3320           break;
3321
3322         case CONFTYPE_REAL:
3323           ST(argvi) = sv_newmortal();
3324           sv_setnv(ST(argvi), val_t__real(result));
3325           argvi++;
3326           break;
3327
3328           case CONFTYPE_IDENT:      /* same as STRING */
3329         case CONFTYPE_STR:
3330         case CONFTYPE_APPLICATION:
3331           ST(argvi) = sv_newmortal();
3332           sv_setpv(ST(argvi), val_t__str(result));
3333           argvi++;
3334           break;
3335
3336           case CONFTYPE_IDENTLIST: {
3337             AV *ilist = newAV();
3338
3339             identlist_t il;
3340             for (il=val_t__identlist(result); il != NULL; il = il->next) {
3341               av_push(ilist, newSVpv((char *)il->data, 0));
3342             }
3343
3344             ST(argvi) = sv_2mortal(newRV_noinc((SV *)ilist));
3345             argvi++;
3346             break;
3347           }
3348
3349           case CONFTYPE_AUTOLABEL: {
3350             autolabel_t *autolabel = &val_t__autolabel(result);
3351             HV *hv;
3352
3353             /* now build the hash */
3354             hv = (HV *)sv_2mortal((SV *)newHV());
3355             hv_store(hv, "template", 8,
3356               (autolabel->template)? newSVpv(autolabel->template, 0) : newSV(0),
3357               0);
3358             hv_store(hv, "other_config", 12,
3359               (autolabel->autolabel & AL_OTHER_CONFIG)? &PL_sv_yes : &PL_sv_no,
3360               0);
3361             hv_store(hv, "non_amanda", 10,
3362               (autolabel->autolabel & AL_NON_AMANDA)? &PL_sv_yes : &PL_sv_no,
3363               0);
3364             hv_store(hv, "volume_error", 12,
3365               (autolabel->autolabel & AL_VOLUME_ERROR)? &PL_sv_yes : &PL_sv_no,
3366               0);
3367             hv_store(hv, "empty", 5,
3368               (autolabel->autolabel & AL_EMPTY)? &PL_sv_yes : &PL_sv_no,
3369               0);
3370
3371             ST(argvi) = sv_2mortal(newRV((SV *)hv));
3372             argvi++;
3373             break;
3374           }
3375
3376           /* No match yet -> not one of the "complex" types */
3377         default:
3378           SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
3379           break;
3380         }
3381       }
3382     }
3383
3384
3385     XSRETURN(argvi);
3386   fail:
3387
3388
3389     SWIG_croak_null();
3390   }
3391 }
3392
3393
3394 XS(_wrap_dumptype_name) {
3395   {
3396     dumptype_t *arg1 = (dumptype_t *) 0 ;
3397     void *argp1 = 0 ;
3398     int res1 = 0 ;
3399     int argvi = 0;
3400     char *result = 0 ;
3401     dXSARGS;
3402
3403     if ((items < 1) || (items > 1)) {
3404       SWIG_croak("Usage: dumptype_name(dtyp);");
3405     }
3406     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumptype_t, 0 |  0 );
3407     if (!SWIG_IsOK(res1)) {
3408       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumptype_name" "', argument " "1"" of type '" "dumptype_t *""'");
3409     }
3410     arg1 = (dumptype_t *)(argp1);
3411     result = (char *)dumptype_name(arg1);
3412     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3413
3414     XSRETURN(argvi);
3415   fail:
3416
3417     SWIG_croak_null();
3418   }
3419 }
3420
3421
3422 XS(_wrap_dumptype_seen) {
3423   {
3424     dumptype_t *arg1 = (dumptype_t *) 0 ;
3425     dumptype_key arg2 ;
3426     void *argp1 = 0 ;
3427     int res1 = 0 ;
3428     int argvi = 0;
3429     gboolean result;
3430     dXSARGS;
3431
3432     if ((items < 2) || (items > 2)) {
3433       SWIG_croak("Usage: dumptype_seen(dtyp,key);");
3434     }
3435     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumptype_t, 0 |  0 );
3436     if (!SWIG_IsOK(res1)) {
3437       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "dumptype_seen" "', argument " "1"" of type '" "dumptype_t *""'");
3438     }
3439     arg1 = (dumptype_t *)(argp1);
3440     {
3441       if (sizeof(signed int) == 1) {
3442         arg2 = amglue_SvI8(ST(1));
3443       } else if (sizeof(signed int) == 2) {
3444         arg2 = amglue_SvI16(ST(1));
3445       } else if (sizeof(signed int) == 4) {
3446         arg2 = amglue_SvI32(ST(1));
3447       } else if (sizeof(signed int) == 8) {
3448         arg2 = amglue_SvI64(ST(1));
3449       } else {
3450         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3451       }
3452     }
3453     result = (gboolean)dumptype_seen(arg1,arg2);
3454     {
3455       if (result)
3456       ST(argvi) = &PL_sv_yes;
3457       else
3458       ST(argvi) = &PL_sv_no;
3459       argvi++;
3460     }
3461
3462
3463     XSRETURN(argvi);
3464   fail:
3465
3466
3467     SWIG_croak_null();
3468   }
3469 }
3470
3471
3472 XS(_wrap_lookup_interface) {
3473   {
3474     char *arg1 = (char *) 0 ;
3475     int res1 ;
3476     char *buf1 = 0 ;
3477     int alloc1 = 0 ;
3478     int argvi = 0;
3479     interface_t *result = 0 ;
3480     dXSARGS;
3481
3482     if ((items < 1) || (items > 1)) {
3483       SWIG_croak("Usage: lookup_interface(identifier);");
3484     }
3485     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
3486     if (!SWIG_IsOK(res1)) {
3487       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lookup_interface" "', argument " "1"" of type '" "char *""'");
3488     }
3489     arg1 = (char *)(buf1);
3490     result = (interface_t *)lookup_interface(arg1);
3491     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_interface_t, 0 | 0); argvi++ ;
3492     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3493     XSRETURN(argvi);
3494   fail:
3495     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3496     SWIG_croak_null();
3497   }
3498 }
3499
3500
3501 XS(_wrap_interface_getconf) {
3502   {
3503     interface_t *arg1 = (interface_t *) 0 ;
3504     interface_key arg2 ;
3505     void *argp1 = 0 ;
3506     int res1 = 0 ;
3507     int argvi = 0;
3508     val_t *result = 0 ;
3509     dXSARGS;
3510
3511     if ((items < 2) || (items > 2)) {
3512       SWIG_croak("Usage: interface_getconf(iface,key);");
3513     }
3514     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_interface_t, 0 |  0 );
3515     if (!SWIG_IsOK(res1)) {
3516       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "interface_getconf" "', argument " "1"" of type '" "interface_t *""'");
3517     }
3518     arg1 = (interface_t *)(argp1);
3519     {
3520       if (sizeof(signed int) == 1) {
3521         arg2 = amglue_SvI8(ST(1));
3522       } else if (sizeof(signed int) == 2) {
3523         arg2 = amglue_SvI16(ST(1));
3524       } else if (sizeof(signed int) == 4) {
3525         arg2 = amglue_SvI32(ST(1));
3526       } else if (sizeof(signed int) == 8) {
3527         arg2 = amglue_SvI64(ST(1));
3528       } else {
3529         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3530       }
3531     }
3532     result = (val_t *)interface_getconf(arg1,arg2);
3533     {
3534       if (!result) {
3535         ST(argvi) = &PL_sv_undef;
3536         argvi++;
3537       } else {
3538         switch (result->type) {
3539           case CONFTYPE_RATE: {
3540             ST(argvi)= sv_newmortal();
3541             sv_setnv(ST(argvi), val_t__rate(result)[0]);
3542             argvi++;
3543
3544             ST(argvi)= sv_newmortal();
3545             sv_setnv(ST(argvi), val_t__rate(result)[1]);
3546             argvi++;
3547             break;
3548           }
3549
3550           case CONFTYPE_INTRANGE: {
3551             ST(argvi)= sv_newmortal();
3552             sv_setiv(ST(argvi), val_t__intrange(result)[0]);
3553             argvi++;
3554
3555             ST(argvi)= sv_newmortal();
3556             sv_setiv(ST(argvi), val_t__intrange(result)[1]);
3557             argvi++;
3558             break;
3559           }
3560
3561           case CONFTYPE_EXINCLUDE: {
3562             /* exincludes are represented in perl as {
3563                          *      'list' : [ 'list1', 'list2', ..],
3564                          *      'file' : [ 'file1', 'file2', ..],
3565                          *      'optional' : 1,
3566                          * }
3567                          */
3568             exinclude_t *ei = &val_t__exinclude(result);
3569             AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
3570             AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
3571             SV *optional = sv_newmortal();
3572             HV *hv;
3573             sle_t *iter;
3574
3575             /* first set up each of the hash values */
3576
3577             if (ei->sl_list) {
3578               for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
3579                 av_push(list_entries, newSVpv(iter->name, 0));
3580               }
3581             }
3582
3583             if(ei->sl_file) {
3584               for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
3585                 av_push(file_entries, newSVpv(iter->name, 0));
3586               }
3587             }
3588
3589             sv_setiv(optional, ei->optional);
3590
3591             /* now build the hash */
3592             hv = (HV *)sv_2mortal((SV *)newHV());
3593
3594             hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
3595             hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
3596             hv_store(hv, "optional", 8, optional, 0);
3597             SvREFCNT_inc(optional);
3598
3599             ST(argvi) = sv_2mortal(newRV((SV *)hv));
3600             argvi++;
3601             break;
3602           }
3603
3604         case CONFTYPE_PROPLIST:
3605           ST(argvi) = sv_2mortal(g_hash_table_to_hashref_property(val_t__proplist(result)));
3606           argvi++;
3607           break;
3608
3609         case CONFTYPE_SIZE:
3610           SP += argvi; PUTBACK;
3611           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
3612           SPAGAIN; SP -= argvi; argvi++;
3613           break;
3614
3615         case CONFTYPE_INT64:
3616           SP += argvi; PUTBACK;
3617           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int64(result)));
3618           SPAGAIN; SP -= argvi; argvi++;
3619           break;
3620
3621           case CONFTYPE_BOOLEAN:            /* all same as INT.. */
3622         case CONFTYPE_COMPRESS:
3623         case CONFTYPE_ENCRYPT:
3624         case CONFTYPE_STRATEGY:
3625         case CONFTYPE_TAPERALGO:
3626         case CONFTYPE_PRIORITY:
3627         case CONFTYPE_HOLDING:
3628         case CONFTYPE_EXECUTE_ON:
3629         case CONFTYPE_EXECUTE_WHERE:
3630         case CONFTYPE_SEND_AMREPORT_ON:
3631         case CONFTYPE_DATA_PATH:
3632         case CONFTYPE_INT:
3633           SP += argvi; PUTBACK;
3634           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
3635           SPAGAIN; SP -= argvi; argvi++;
3636           break;
3637
3638           case CONFTYPE_ESTIMATELIST: {
3639             AV *elist = newAV();
3640             estimatelist_t el;
3641             for (el=val_t__estimatelist(result); el != NULL; el = el->next) {
3642               av_push(elist, newSVuv(GPOINTER_TO_INT(el->data)));
3643             }
3644             ST(argvi) = sv_2mortal(newRV_noinc((SV *)elist));
3645             argvi++;
3646             break;
3647           }
3648
3649         case CONFTYPE_TIME:
3650           SP += argvi; PUTBACK;
3651           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
3652           SPAGAIN; SP -= argvi; argvi++;
3653           break;
3654
3655         case CONFTYPE_REAL:
3656           ST(argvi) = sv_newmortal();
3657           sv_setnv(ST(argvi), val_t__real(result));
3658           argvi++;
3659           break;
3660
3661           case CONFTYPE_IDENT:      /* same as STRING */
3662         case CONFTYPE_STR:
3663         case CONFTYPE_APPLICATION:
3664           ST(argvi) = sv_newmortal();
3665           sv_setpv(ST(argvi), val_t__str(result));
3666           argvi++;
3667           break;
3668
3669           case CONFTYPE_IDENTLIST: {
3670             AV *ilist = newAV();
3671
3672             identlist_t il;
3673             for (il=val_t__identlist(result); il != NULL; il = il->next) {
3674               av_push(ilist, newSVpv((char *)il->data, 0));
3675             }
3676
3677             ST(argvi) = sv_2mortal(newRV_noinc((SV *)ilist));
3678             argvi++;
3679             break;
3680           }
3681
3682           case CONFTYPE_AUTOLABEL: {
3683             autolabel_t *autolabel = &val_t__autolabel(result);
3684             HV *hv;
3685
3686             /* now build the hash */
3687             hv = (HV *)sv_2mortal((SV *)newHV());
3688             hv_store(hv, "template", 8,
3689               (autolabel->template)? newSVpv(autolabel->template, 0) : newSV(0),
3690               0);
3691             hv_store(hv, "other_config", 12,
3692               (autolabel->autolabel & AL_OTHER_CONFIG)? &PL_sv_yes : &PL_sv_no,
3693               0);
3694             hv_store(hv, "non_amanda", 10,
3695               (autolabel->autolabel & AL_NON_AMANDA)? &PL_sv_yes : &PL_sv_no,
3696               0);
3697             hv_store(hv, "volume_error", 12,
3698               (autolabel->autolabel & AL_VOLUME_ERROR)? &PL_sv_yes : &PL_sv_no,
3699               0);
3700             hv_store(hv, "empty", 5,
3701               (autolabel->autolabel & AL_EMPTY)? &PL_sv_yes : &PL_sv_no,
3702               0);
3703
3704             ST(argvi) = sv_2mortal(newRV((SV *)hv));
3705             argvi++;
3706             break;
3707           }
3708
3709           /* No match yet -> not one of the "complex" types */
3710         default:
3711           SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
3712           break;
3713         }
3714       }
3715     }
3716
3717
3718     XSRETURN(argvi);
3719   fail:
3720
3721
3722     SWIG_croak_null();
3723   }
3724 }
3725
3726
3727 XS(_wrap_interface_name) {
3728   {
3729     interface_t *arg1 = (interface_t *) 0 ;
3730     void *argp1 = 0 ;
3731     int res1 = 0 ;
3732     int argvi = 0;
3733     char *result = 0 ;
3734     dXSARGS;
3735
3736     if ((items < 1) || (items > 1)) {
3737       SWIG_croak("Usage: interface_name(iface);");
3738     }
3739     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_interface_t, 0 |  0 );
3740     if (!SWIG_IsOK(res1)) {
3741       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "interface_name" "', argument " "1"" of type '" "interface_t *""'");
3742     }
3743     arg1 = (interface_t *)(argp1);
3744     result = (char *)interface_name(arg1);
3745     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3746
3747     XSRETURN(argvi);
3748   fail:
3749
3750     SWIG_croak_null();
3751   }
3752 }
3753
3754
3755 XS(_wrap_interface_seen) {
3756   {
3757     interface_t *arg1 = (interface_t *) 0 ;
3758     interface_key arg2 ;
3759     void *argp1 = 0 ;
3760     int res1 = 0 ;
3761     int argvi = 0;
3762     gboolean result;
3763     dXSARGS;
3764
3765     if ((items < 2) || (items > 2)) {
3766       SWIG_croak("Usage: interface_seen(iface,key);");
3767     }
3768     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_interface_t, 0 |  0 );
3769     if (!SWIG_IsOK(res1)) {
3770       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "interface_seen" "', argument " "1"" of type '" "interface_t *""'");
3771     }
3772     arg1 = (interface_t *)(argp1);
3773     {
3774       if (sizeof(signed int) == 1) {
3775         arg2 = amglue_SvI8(ST(1));
3776       } else if (sizeof(signed int) == 2) {
3777         arg2 = amglue_SvI16(ST(1));
3778       } else if (sizeof(signed int) == 4) {
3779         arg2 = amglue_SvI32(ST(1));
3780       } else if (sizeof(signed int) == 8) {
3781         arg2 = amglue_SvI64(ST(1));
3782       } else {
3783         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3784       }
3785     }
3786     result = (gboolean)interface_seen(arg1,arg2);
3787     {
3788       if (result)
3789       ST(argvi) = &PL_sv_yes;
3790       else
3791       ST(argvi) = &PL_sv_no;
3792       argvi++;
3793     }
3794
3795
3796     XSRETURN(argvi);
3797   fail:
3798
3799
3800     SWIG_croak_null();
3801   }
3802 }
3803
3804
3805 XS(_wrap_lookup_holdingdisk) {
3806   {
3807     char *arg1 = (char *) 0 ;
3808     int res1 ;
3809     char *buf1 = 0 ;
3810     int alloc1 = 0 ;
3811     int argvi = 0;
3812     holdingdisk_t *result = 0 ;
3813     dXSARGS;
3814
3815     if ((items < 1) || (items > 1)) {
3816       SWIG_croak("Usage: lookup_holdingdisk(identifier);");
3817     }
3818     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
3819     if (!SWIG_IsOK(res1)) {
3820       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lookup_holdingdisk" "', argument " "1"" of type '" "char *""'");
3821     }
3822     arg1 = (char *)(buf1);
3823     result = (holdingdisk_t *)lookup_holdingdisk(arg1);
3824     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_holdingdisk_t, 0 | 0); argvi++ ;
3825     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3826     XSRETURN(argvi);
3827   fail:
3828     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
3829     SWIG_croak_null();
3830   }
3831 }
3832
3833
3834 XS(_wrap_getconf_holdingdisks) {
3835   {
3836     int argvi = 0;
3837     GSList *result = 0 ;
3838     dXSARGS;
3839
3840     if ((items < 0) || (items > 0)) {
3841       SWIG_croak("Usage: getconf_holdingdisks();");
3842     }
3843     result = (GSList *)getconf_holdingdisks();
3844     {
3845       GSList *it = result;
3846
3847       while (it) {
3848         ST(argvi) = sv_2mortal(newSVpv(it->data, 0));
3849         argvi++;
3850         it = it->next;
3851       }
3852
3853       g_slist_free(result);
3854     }
3855     XSRETURN(argvi);
3856   fail:
3857     SWIG_croak_null();
3858   }
3859 }
3860
3861
3862 XS(_wrap_holdingdisk_getconf) {
3863   {
3864     holdingdisk_t *arg1 = (holdingdisk_t *) 0 ;
3865     holdingdisk_key arg2 ;
3866     void *argp1 = 0 ;
3867     int res1 = 0 ;
3868     int argvi = 0;
3869     val_t *result = 0 ;
3870     dXSARGS;
3871
3872     if ((items < 2) || (items > 2)) {
3873       SWIG_croak("Usage: holdingdisk_getconf(hdisk,key);");
3874     }
3875     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_holdingdisk_t, 0 |  0 );
3876     if (!SWIG_IsOK(res1)) {
3877       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "holdingdisk_getconf" "', argument " "1"" of type '" "holdingdisk_t *""'");
3878     }
3879     arg1 = (holdingdisk_t *)(argp1);
3880     {
3881       if (sizeof(signed int) == 1) {
3882         arg2 = amglue_SvI8(ST(1));
3883       } else if (sizeof(signed int) == 2) {
3884         arg2 = amglue_SvI16(ST(1));
3885       } else if (sizeof(signed int) == 4) {
3886         arg2 = amglue_SvI32(ST(1));
3887       } else if (sizeof(signed int) == 8) {
3888         arg2 = amglue_SvI64(ST(1));
3889       } else {
3890         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3891       }
3892     }
3893     result = (val_t *)holdingdisk_getconf(arg1,arg2);
3894     {
3895       if (!result) {
3896         ST(argvi) = &PL_sv_undef;
3897         argvi++;
3898       } else {
3899         switch (result->type) {
3900           case CONFTYPE_RATE: {
3901             ST(argvi)= sv_newmortal();
3902             sv_setnv(ST(argvi), val_t__rate(result)[0]);
3903             argvi++;
3904
3905             ST(argvi)= sv_newmortal();
3906             sv_setnv(ST(argvi), val_t__rate(result)[1]);
3907             argvi++;
3908             break;
3909           }
3910
3911           case CONFTYPE_INTRANGE: {
3912             ST(argvi)= sv_newmortal();
3913             sv_setiv(ST(argvi), val_t__intrange(result)[0]);
3914             argvi++;
3915
3916             ST(argvi)= sv_newmortal();
3917             sv_setiv(ST(argvi), val_t__intrange(result)[1]);
3918             argvi++;
3919             break;
3920           }
3921
3922           case CONFTYPE_EXINCLUDE: {
3923             /* exincludes are represented in perl as {
3924                          *      'list' : [ 'list1', 'list2', ..],
3925                          *      'file' : [ 'file1', 'file2', ..],
3926                          *      'optional' : 1,
3927                          * }
3928                          */
3929             exinclude_t *ei = &val_t__exinclude(result);
3930             AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
3931             AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
3932             SV *optional = sv_newmortal();
3933             HV *hv;
3934             sle_t *iter;
3935
3936             /* first set up each of the hash values */
3937
3938             if (ei->sl_list) {
3939               for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
3940                 av_push(list_entries, newSVpv(iter->name, 0));
3941               }
3942             }
3943
3944             if(ei->sl_file) {
3945               for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
3946                 av_push(file_entries, newSVpv(iter->name, 0));
3947               }
3948             }
3949
3950             sv_setiv(optional, ei->optional);
3951
3952             /* now build the hash */
3953             hv = (HV *)sv_2mortal((SV *)newHV());
3954
3955             hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
3956             hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
3957             hv_store(hv, "optional", 8, optional, 0);
3958             SvREFCNT_inc(optional);
3959
3960             ST(argvi) = sv_2mortal(newRV((SV *)hv));
3961             argvi++;
3962             break;
3963           }
3964
3965         case CONFTYPE_PROPLIST:
3966           ST(argvi) = sv_2mortal(g_hash_table_to_hashref_property(val_t__proplist(result)));
3967           argvi++;
3968           break;
3969
3970         case CONFTYPE_SIZE:
3971           SP += argvi; PUTBACK;
3972           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
3973           SPAGAIN; SP -= argvi; argvi++;
3974           break;
3975
3976         case CONFTYPE_INT64:
3977           SP += argvi; PUTBACK;
3978           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int64(result)));
3979           SPAGAIN; SP -= argvi; argvi++;
3980           break;
3981
3982           case CONFTYPE_BOOLEAN:            /* all same as INT.. */
3983         case CONFTYPE_COMPRESS:
3984         case CONFTYPE_ENCRYPT:
3985         case CONFTYPE_STRATEGY:
3986         case CONFTYPE_TAPERALGO:
3987         case CONFTYPE_PRIORITY:
3988         case CONFTYPE_HOLDING:
3989         case CONFTYPE_EXECUTE_ON:
3990         case CONFTYPE_EXECUTE_WHERE:
3991         case CONFTYPE_SEND_AMREPORT_ON:
3992         case CONFTYPE_DATA_PATH:
3993         case CONFTYPE_INT:
3994           SP += argvi; PUTBACK;
3995           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
3996           SPAGAIN; SP -= argvi; argvi++;
3997           break;
3998
3999           case CONFTYPE_ESTIMATELIST: {
4000             AV *elist = newAV();
4001             estimatelist_t el;
4002             for (el=val_t__estimatelist(result); el != NULL; el = el->next) {
4003               av_push(elist, newSVuv(GPOINTER_TO_INT(el->data)));
4004             }
4005             ST(argvi) = sv_2mortal(newRV_noinc((SV *)elist));
4006             argvi++;
4007             break;
4008           }
4009
4010         case CONFTYPE_TIME:
4011           SP += argvi; PUTBACK;
4012           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
4013           SPAGAIN; SP -= argvi; argvi++;
4014           break;
4015
4016         case CONFTYPE_REAL:
4017           ST(argvi) = sv_newmortal();
4018           sv_setnv(ST(argvi), val_t__real(result));
4019           argvi++;
4020           break;
4021
4022           case CONFTYPE_IDENT:      /* same as STRING */
4023         case CONFTYPE_STR:
4024         case CONFTYPE_APPLICATION:
4025           ST(argvi) = sv_newmortal();
4026           sv_setpv(ST(argvi), val_t__str(result));
4027           argvi++;
4028           break;
4029
4030           case CONFTYPE_IDENTLIST: {
4031             AV *ilist = newAV();
4032
4033             identlist_t il;
4034             for (il=val_t__identlist(result); il != NULL; il = il->next) {
4035               av_push(ilist, newSVpv((char *)il->data, 0));
4036             }
4037
4038             ST(argvi) = sv_2mortal(newRV_noinc((SV *)ilist));
4039             argvi++;
4040             break;
4041           }
4042
4043           case CONFTYPE_AUTOLABEL: {
4044             autolabel_t *autolabel = &val_t__autolabel(result);
4045             HV *hv;
4046
4047             /* now build the hash */
4048             hv = (HV *)sv_2mortal((SV *)newHV());
4049             hv_store(hv, "template", 8,
4050               (autolabel->template)? newSVpv(autolabel->template, 0) : newSV(0),
4051               0);
4052             hv_store(hv, "other_config", 12,
4053               (autolabel->autolabel & AL_OTHER_CONFIG)? &PL_sv_yes : &PL_sv_no,
4054               0);
4055             hv_store(hv, "non_amanda", 10,
4056               (autolabel->autolabel & AL_NON_AMANDA)? &PL_sv_yes : &PL_sv_no,
4057               0);
4058             hv_store(hv, "volume_error", 12,
4059               (autolabel->autolabel & AL_VOLUME_ERROR)? &PL_sv_yes : &PL_sv_no,
4060               0);
4061             hv_store(hv, "empty", 5,
4062               (autolabel->autolabel & AL_EMPTY)? &PL_sv_yes : &PL_sv_no,
4063               0);
4064
4065             ST(argvi) = sv_2mortal(newRV((SV *)hv));
4066             argvi++;
4067             break;
4068           }
4069
4070           /* No match yet -> not one of the "complex" types */
4071         default:
4072           SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
4073           break;
4074         }
4075       }
4076     }
4077
4078
4079     XSRETURN(argvi);
4080   fail:
4081
4082
4083     SWIG_croak_null();
4084   }
4085 }
4086
4087
4088 XS(_wrap_holdingdisk_name) {
4089   {
4090     holdingdisk_t *arg1 = (holdingdisk_t *) 0 ;
4091     void *argp1 = 0 ;
4092     int res1 = 0 ;
4093     int argvi = 0;
4094     char *result = 0 ;
4095     dXSARGS;
4096
4097     if ((items < 1) || (items > 1)) {
4098       SWIG_croak("Usage: holdingdisk_name(hdisk);");
4099     }
4100     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_holdingdisk_t, 0 |  0 );
4101     if (!SWIG_IsOK(res1)) {
4102       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "holdingdisk_name" "', argument " "1"" of type '" "holdingdisk_t *""'");
4103     }
4104     arg1 = (holdingdisk_t *)(argp1);
4105     result = (char *)holdingdisk_name(arg1);
4106     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4107
4108     XSRETURN(argvi);
4109   fail:
4110
4111     SWIG_croak_null();
4112   }
4113 }
4114
4115
4116 XS(_wrap_holdingdisk_seen) {
4117   {
4118     holdingdisk_t *arg1 = (holdingdisk_t *) 0 ;
4119     holdingdisk_key arg2 ;
4120     void *argp1 = 0 ;
4121     int res1 = 0 ;
4122     int argvi = 0;
4123     gboolean result;
4124     dXSARGS;
4125
4126     if ((items < 2) || (items > 2)) {
4127       SWIG_croak("Usage: holdingdisk_seen(hdisk,key);");
4128     }
4129     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_holdingdisk_t, 0 |  0 );
4130     if (!SWIG_IsOK(res1)) {
4131       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "holdingdisk_seen" "', argument " "1"" of type '" "holdingdisk_t *""'");
4132     }
4133     arg1 = (holdingdisk_t *)(argp1);
4134     {
4135       if (sizeof(signed int) == 1) {
4136         arg2 = amglue_SvI8(ST(1));
4137       } else if (sizeof(signed int) == 2) {
4138         arg2 = amglue_SvI16(ST(1));
4139       } else if (sizeof(signed int) == 4) {
4140         arg2 = amglue_SvI32(ST(1));
4141       } else if (sizeof(signed int) == 8) {
4142         arg2 = amglue_SvI64(ST(1));
4143       } else {
4144         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4145       }
4146     }
4147     result = (gboolean)holdingdisk_seen(arg1,arg2);
4148     {
4149       if (result)
4150       ST(argvi) = &PL_sv_yes;
4151       else
4152       ST(argvi) = &PL_sv_no;
4153       argvi++;
4154     }
4155
4156
4157     XSRETURN(argvi);
4158   fail:
4159
4160
4161     SWIG_croak_null();
4162   }
4163 }
4164
4165
4166 XS(_wrap_lookup_application) {
4167   {
4168     char *arg1 = (char *) 0 ;
4169     int res1 ;
4170     char *buf1 = 0 ;
4171     int alloc1 = 0 ;
4172     int argvi = 0;
4173     application_t *result = 0 ;
4174     dXSARGS;
4175
4176     if ((items < 1) || (items > 1)) {
4177       SWIG_croak("Usage: lookup_application(identifier);");
4178     }
4179     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
4180     if (!SWIG_IsOK(res1)) {
4181       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lookup_application" "', argument " "1"" of type '" "char *""'");
4182     }
4183     arg1 = (char *)(buf1);
4184     result = (application_t *)lookup_application(arg1);
4185     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_application_t, 0 | 0); argvi++ ;
4186     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4187     XSRETURN(argvi);
4188   fail:
4189     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4190     SWIG_croak_null();
4191   }
4192 }
4193
4194
4195 XS(_wrap_application_getconf) {
4196   {
4197     application_t *arg1 = (application_t *) 0 ;
4198     application_key arg2 ;
4199     void *argp1 = 0 ;
4200     int res1 = 0 ;
4201     int argvi = 0;
4202     val_t *result = 0 ;
4203     dXSARGS;
4204
4205     if ((items < 2) || (items > 2)) {
4206       SWIG_croak("Usage: application_getconf(app,key);");
4207     }
4208     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_application_t, 0 |  0 );
4209     if (!SWIG_IsOK(res1)) {
4210       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "application_getconf" "', argument " "1"" of type '" "application_t *""'");
4211     }
4212     arg1 = (application_t *)(argp1);
4213     {
4214       if (sizeof(signed int) == 1) {
4215         arg2 = amglue_SvI8(ST(1));
4216       } else if (sizeof(signed int) == 2) {
4217         arg2 = amglue_SvI16(ST(1));
4218       } else if (sizeof(signed int) == 4) {
4219         arg2 = amglue_SvI32(ST(1));
4220       } else if (sizeof(signed int) == 8) {
4221         arg2 = amglue_SvI64(ST(1));
4222       } else {
4223         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4224       }
4225     }
4226     result = (val_t *)application_getconf(arg1,arg2);
4227     {
4228       if (!result) {
4229         ST(argvi) = &PL_sv_undef;
4230         argvi++;
4231       } else {
4232         switch (result->type) {
4233           case CONFTYPE_RATE: {
4234             ST(argvi)= sv_newmortal();
4235             sv_setnv(ST(argvi), val_t__rate(result)[0]);
4236             argvi++;
4237
4238             ST(argvi)= sv_newmortal();
4239             sv_setnv(ST(argvi), val_t__rate(result)[1]);
4240             argvi++;
4241             break;
4242           }
4243
4244           case CONFTYPE_INTRANGE: {
4245             ST(argvi)= sv_newmortal();
4246             sv_setiv(ST(argvi), val_t__intrange(result)[0]);
4247             argvi++;
4248
4249             ST(argvi)= sv_newmortal();
4250             sv_setiv(ST(argvi), val_t__intrange(result)[1]);
4251             argvi++;
4252             break;
4253           }
4254
4255           case CONFTYPE_EXINCLUDE: {
4256             /* exincludes are represented in perl as {
4257                          *      'list' : [ 'list1', 'list2', ..],
4258                          *      'file' : [ 'file1', 'file2', ..],
4259                          *      'optional' : 1,
4260                          * }
4261                          */
4262             exinclude_t *ei = &val_t__exinclude(result);
4263             AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
4264             AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
4265             SV *optional = sv_newmortal();
4266             HV *hv;
4267             sle_t *iter;
4268
4269             /* first set up each of the hash values */
4270
4271             if (ei->sl_list) {
4272               for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
4273                 av_push(list_entries, newSVpv(iter->name, 0));
4274               }
4275             }
4276
4277             if(ei->sl_file) {
4278               for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
4279                 av_push(file_entries, newSVpv(iter->name, 0));
4280               }
4281             }
4282
4283             sv_setiv(optional, ei->optional);
4284
4285             /* now build the hash */
4286             hv = (HV *)sv_2mortal((SV *)newHV());
4287
4288             hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
4289             hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
4290             hv_store(hv, "optional", 8, optional, 0);
4291             SvREFCNT_inc(optional);
4292
4293             ST(argvi) = sv_2mortal(newRV((SV *)hv));
4294             argvi++;
4295             break;
4296           }
4297
4298         case CONFTYPE_PROPLIST:
4299           ST(argvi) = sv_2mortal(g_hash_table_to_hashref_property(val_t__proplist(result)));
4300           argvi++;
4301           break;
4302
4303         case CONFTYPE_SIZE:
4304           SP += argvi; PUTBACK;
4305           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
4306           SPAGAIN; SP -= argvi; argvi++;
4307           break;
4308
4309         case CONFTYPE_INT64:
4310           SP += argvi; PUTBACK;
4311           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int64(result)));
4312           SPAGAIN; SP -= argvi; argvi++;
4313           break;
4314
4315           case CONFTYPE_BOOLEAN:            /* all same as INT.. */
4316         case CONFTYPE_COMPRESS:
4317         case CONFTYPE_ENCRYPT:
4318         case CONFTYPE_STRATEGY:
4319         case CONFTYPE_TAPERALGO:
4320         case CONFTYPE_PRIORITY:
4321         case CONFTYPE_HOLDING:
4322         case CONFTYPE_EXECUTE_ON:
4323         case CONFTYPE_EXECUTE_WHERE:
4324         case CONFTYPE_SEND_AMREPORT_ON:
4325         case CONFTYPE_DATA_PATH:
4326         case CONFTYPE_INT:
4327           SP += argvi; PUTBACK;
4328           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
4329           SPAGAIN; SP -= argvi; argvi++;
4330           break;
4331
4332           case CONFTYPE_ESTIMATELIST: {
4333             AV *elist = newAV();
4334             estimatelist_t el;
4335             for (el=val_t__estimatelist(result); el != NULL; el = el->next) {
4336               av_push(elist, newSVuv(GPOINTER_TO_INT(el->data)));
4337             }
4338             ST(argvi) = sv_2mortal(newRV_noinc((SV *)elist));
4339             argvi++;
4340             break;
4341           }
4342
4343         case CONFTYPE_TIME:
4344           SP += argvi; PUTBACK;
4345           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
4346           SPAGAIN; SP -= argvi; argvi++;
4347           break;
4348
4349         case CONFTYPE_REAL:
4350           ST(argvi) = sv_newmortal();
4351           sv_setnv(ST(argvi), val_t__real(result));
4352           argvi++;
4353           break;
4354
4355           case CONFTYPE_IDENT:      /* same as STRING */
4356         case CONFTYPE_STR:
4357         case CONFTYPE_APPLICATION:
4358           ST(argvi) = sv_newmortal();
4359           sv_setpv(ST(argvi), val_t__str(result));
4360           argvi++;
4361           break;
4362
4363           case CONFTYPE_IDENTLIST: {
4364             AV *ilist = newAV();
4365
4366             identlist_t il;
4367             for (il=val_t__identlist(result); il != NULL; il = il->next) {
4368               av_push(ilist, newSVpv((char *)il->data, 0));
4369             }
4370
4371             ST(argvi) = sv_2mortal(newRV_noinc((SV *)ilist));
4372             argvi++;
4373             break;
4374           }
4375
4376           case CONFTYPE_AUTOLABEL: {
4377             autolabel_t *autolabel = &val_t__autolabel(result);
4378             HV *hv;
4379
4380             /* now build the hash */
4381             hv = (HV *)sv_2mortal((SV *)newHV());
4382             hv_store(hv, "template", 8,
4383               (autolabel->template)? newSVpv(autolabel->template, 0) : newSV(0),
4384               0);
4385             hv_store(hv, "other_config", 12,
4386               (autolabel->autolabel & AL_OTHER_CONFIG)? &PL_sv_yes : &PL_sv_no,
4387               0);
4388             hv_store(hv, "non_amanda", 10,
4389               (autolabel->autolabel & AL_NON_AMANDA)? &PL_sv_yes : &PL_sv_no,
4390               0);
4391             hv_store(hv, "volume_error", 12,
4392               (autolabel->autolabel & AL_VOLUME_ERROR)? &PL_sv_yes : &PL_sv_no,
4393               0);
4394             hv_store(hv, "empty", 5,
4395               (autolabel->autolabel & AL_EMPTY)? &PL_sv_yes : &PL_sv_no,
4396               0);
4397
4398             ST(argvi) = sv_2mortal(newRV((SV *)hv));
4399             argvi++;
4400             break;
4401           }
4402
4403           /* No match yet -> not one of the "complex" types */
4404         default:
4405           SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
4406           break;
4407         }
4408       }
4409     }
4410
4411
4412     XSRETURN(argvi);
4413   fail:
4414
4415
4416     SWIG_croak_null();
4417   }
4418 }
4419
4420
4421 XS(_wrap_application_name) {
4422   {
4423     application_t *arg1 = (application_t *) 0 ;
4424     void *argp1 = 0 ;
4425     int res1 = 0 ;
4426     int argvi = 0;
4427     char *result = 0 ;
4428     dXSARGS;
4429
4430     if ((items < 1) || (items > 1)) {
4431       SWIG_croak("Usage: application_name(app);");
4432     }
4433     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_application_t, 0 |  0 );
4434     if (!SWIG_IsOK(res1)) {
4435       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "application_name" "', argument " "1"" of type '" "application_t *""'");
4436     }
4437     arg1 = (application_t *)(argp1);
4438     result = (char *)application_name(arg1);
4439     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4440
4441     XSRETURN(argvi);
4442   fail:
4443
4444     SWIG_croak_null();
4445   }
4446 }
4447
4448
4449 XS(_wrap_application_seen) {
4450   {
4451     application_t *arg1 = (application_t *) 0 ;
4452     application_key arg2 ;
4453     void *argp1 = 0 ;
4454     int res1 = 0 ;
4455     int argvi = 0;
4456     gboolean result;
4457     dXSARGS;
4458
4459     if ((items < 2) || (items > 2)) {
4460       SWIG_croak("Usage: application_seen(app,key);");
4461     }
4462     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_application_t, 0 |  0 );
4463     if (!SWIG_IsOK(res1)) {
4464       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "application_seen" "', argument " "1"" of type '" "application_t *""'");
4465     }
4466     arg1 = (application_t *)(argp1);
4467     {
4468       if (sizeof(signed int) == 1) {
4469         arg2 = amglue_SvI8(ST(1));
4470       } else if (sizeof(signed int) == 2) {
4471         arg2 = amglue_SvI16(ST(1));
4472       } else if (sizeof(signed int) == 4) {
4473         arg2 = amglue_SvI32(ST(1));
4474       } else if (sizeof(signed int) == 8) {
4475         arg2 = amglue_SvI64(ST(1));
4476       } else {
4477         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4478       }
4479     }
4480     result = (gboolean)application_seen(arg1,arg2);
4481     {
4482       if (result)
4483       ST(argvi) = &PL_sv_yes;
4484       else
4485       ST(argvi) = &PL_sv_no;
4486       argvi++;
4487     }
4488
4489
4490     XSRETURN(argvi);
4491   fail:
4492
4493
4494     SWIG_croak_null();
4495   }
4496 }
4497
4498
4499 XS(_wrap_lookup_pp_script) {
4500   {
4501     char *arg1 = (char *) 0 ;
4502     int res1 ;
4503     char *buf1 = 0 ;
4504     int alloc1 = 0 ;
4505     int argvi = 0;
4506     pp_script_t *result = 0 ;
4507     dXSARGS;
4508
4509     if ((items < 1) || (items > 1)) {
4510       SWIG_croak("Usage: lookup_pp_script(identifier);");
4511     }
4512     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
4513     if (!SWIG_IsOK(res1)) {
4514       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lookup_pp_script" "', argument " "1"" of type '" "char *""'");
4515     }
4516     arg1 = (char *)(buf1);
4517     result = (pp_script_t *)lookup_pp_script(arg1);
4518     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pp_script_t, 0 | 0); argvi++ ;
4519     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4520     XSRETURN(argvi);
4521   fail:
4522     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4523     SWIG_croak_null();
4524   }
4525 }
4526
4527
4528 XS(_wrap_pp_script_getconf) {
4529   {
4530     pp_script_t *arg1 = (pp_script_t *) 0 ;
4531     pp_script_key arg2 ;
4532     void *argp1 = 0 ;
4533     int res1 = 0 ;
4534     int argvi = 0;
4535     val_t *result = 0 ;
4536     dXSARGS;
4537
4538     if ((items < 2) || (items > 2)) {
4539       SWIG_croak("Usage: pp_script_getconf(pps,key);");
4540     }
4541     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_pp_script_t, 0 |  0 );
4542     if (!SWIG_IsOK(res1)) {
4543       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pp_script_getconf" "', argument " "1"" of type '" "pp_script_t *""'");
4544     }
4545     arg1 = (pp_script_t *)(argp1);
4546     {
4547       if (sizeof(signed int) == 1) {
4548         arg2 = amglue_SvI8(ST(1));
4549       } else if (sizeof(signed int) == 2) {
4550         arg2 = amglue_SvI16(ST(1));
4551       } else if (sizeof(signed int) == 4) {
4552         arg2 = amglue_SvI32(ST(1));
4553       } else if (sizeof(signed int) == 8) {
4554         arg2 = amglue_SvI64(ST(1));
4555       } else {
4556         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4557       }
4558     }
4559     result = (val_t *)pp_script_getconf(arg1,arg2);
4560     {
4561       if (!result) {
4562         ST(argvi) = &PL_sv_undef;
4563         argvi++;
4564       } else {
4565         switch (result->type) {
4566           case CONFTYPE_RATE: {
4567             ST(argvi)= sv_newmortal();
4568             sv_setnv(ST(argvi), val_t__rate(result)[0]);
4569             argvi++;
4570
4571             ST(argvi)= sv_newmortal();
4572             sv_setnv(ST(argvi), val_t__rate(result)[1]);
4573             argvi++;
4574             break;
4575           }
4576
4577           case CONFTYPE_INTRANGE: {
4578             ST(argvi)= sv_newmortal();
4579             sv_setiv(ST(argvi), val_t__intrange(result)[0]);
4580             argvi++;
4581
4582             ST(argvi)= sv_newmortal();
4583             sv_setiv(ST(argvi), val_t__intrange(result)[1]);
4584             argvi++;
4585             break;
4586           }
4587
4588           case CONFTYPE_EXINCLUDE: {
4589             /* exincludes are represented in perl as {
4590                          *      'list' : [ 'list1', 'list2', ..],
4591                          *      'file' : [ 'file1', 'file2', ..],
4592                          *      'optional' : 1,
4593                          * }
4594                          */
4595             exinclude_t *ei = &val_t__exinclude(result);
4596             AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
4597             AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
4598             SV *optional = sv_newmortal();
4599             HV *hv;
4600             sle_t *iter;
4601
4602             /* first set up each of the hash values */
4603
4604             if (ei->sl_list) {
4605               for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
4606                 av_push(list_entries, newSVpv(iter->name, 0));
4607               }
4608             }
4609
4610             if(ei->sl_file) {
4611               for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
4612                 av_push(file_entries, newSVpv(iter->name, 0));
4613               }
4614             }
4615
4616             sv_setiv(optional, ei->optional);
4617
4618             /* now build the hash */
4619             hv = (HV *)sv_2mortal((SV *)newHV());
4620
4621             hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
4622             hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
4623             hv_store(hv, "optional", 8, optional, 0);
4624             SvREFCNT_inc(optional);
4625
4626             ST(argvi) = sv_2mortal(newRV((SV *)hv));
4627             argvi++;
4628             break;
4629           }
4630
4631         case CONFTYPE_PROPLIST:
4632           ST(argvi) = sv_2mortal(g_hash_table_to_hashref_property(val_t__proplist(result)));
4633           argvi++;
4634           break;
4635
4636         case CONFTYPE_SIZE:
4637           SP += argvi; PUTBACK;
4638           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
4639           SPAGAIN; SP -= argvi; argvi++;
4640           break;
4641
4642         case CONFTYPE_INT64:
4643           SP += argvi; PUTBACK;
4644           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int64(result)));
4645           SPAGAIN; SP -= argvi; argvi++;
4646           break;
4647
4648           case CONFTYPE_BOOLEAN:            /* all same as INT.. */
4649         case CONFTYPE_COMPRESS:
4650         case CONFTYPE_ENCRYPT:
4651         case CONFTYPE_STRATEGY:
4652         case CONFTYPE_TAPERALGO:
4653         case CONFTYPE_PRIORITY:
4654         case CONFTYPE_HOLDING:
4655         case CONFTYPE_EXECUTE_ON:
4656         case CONFTYPE_EXECUTE_WHERE:
4657         case CONFTYPE_SEND_AMREPORT_ON:
4658         case CONFTYPE_DATA_PATH:
4659         case CONFTYPE_INT:
4660           SP += argvi; PUTBACK;
4661           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
4662           SPAGAIN; SP -= argvi; argvi++;
4663           break;
4664
4665           case CONFTYPE_ESTIMATELIST: {
4666             AV *elist = newAV();
4667             estimatelist_t el;
4668             for (el=val_t__estimatelist(result); el != NULL; el = el->next) {
4669               av_push(elist, newSVuv(GPOINTER_TO_INT(el->data)));
4670             }
4671             ST(argvi) = sv_2mortal(newRV_noinc((SV *)elist));
4672             argvi++;
4673             break;
4674           }
4675
4676         case CONFTYPE_TIME:
4677           SP += argvi; PUTBACK;
4678           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
4679           SPAGAIN; SP -= argvi; argvi++;
4680           break;
4681
4682         case CONFTYPE_REAL:
4683           ST(argvi) = sv_newmortal();
4684           sv_setnv(ST(argvi), val_t__real(result));
4685           argvi++;
4686           break;
4687
4688           case CONFTYPE_IDENT:      /* same as STRING */
4689         case CONFTYPE_STR:
4690         case CONFTYPE_APPLICATION:
4691           ST(argvi) = sv_newmortal();
4692           sv_setpv(ST(argvi), val_t__str(result));
4693           argvi++;
4694           break;
4695
4696           case CONFTYPE_IDENTLIST: {
4697             AV *ilist = newAV();
4698
4699             identlist_t il;
4700             for (il=val_t__identlist(result); il != NULL; il = il->next) {
4701               av_push(ilist, newSVpv((char *)il->data, 0));
4702             }
4703
4704             ST(argvi) = sv_2mortal(newRV_noinc((SV *)ilist));
4705             argvi++;
4706             break;
4707           }
4708
4709           case CONFTYPE_AUTOLABEL: {
4710             autolabel_t *autolabel = &val_t__autolabel(result);
4711             HV *hv;
4712
4713             /* now build the hash */
4714             hv = (HV *)sv_2mortal((SV *)newHV());
4715             hv_store(hv, "template", 8,
4716               (autolabel->template)? newSVpv(autolabel->template, 0) : newSV(0),
4717               0);
4718             hv_store(hv, "other_config", 12,
4719               (autolabel->autolabel & AL_OTHER_CONFIG)? &PL_sv_yes : &PL_sv_no,
4720               0);
4721             hv_store(hv, "non_amanda", 10,
4722               (autolabel->autolabel & AL_NON_AMANDA)? &PL_sv_yes : &PL_sv_no,
4723               0);
4724             hv_store(hv, "volume_error", 12,
4725               (autolabel->autolabel & AL_VOLUME_ERROR)? &PL_sv_yes : &PL_sv_no,
4726               0);
4727             hv_store(hv, "empty", 5,
4728               (autolabel->autolabel & AL_EMPTY)? &PL_sv_yes : &PL_sv_no,
4729               0);
4730
4731             ST(argvi) = sv_2mortal(newRV((SV *)hv));
4732             argvi++;
4733             break;
4734           }
4735
4736           /* No match yet -> not one of the "complex" types */
4737         default:
4738           SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
4739           break;
4740         }
4741       }
4742     }
4743
4744
4745     XSRETURN(argvi);
4746   fail:
4747
4748
4749     SWIG_croak_null();
4750   }
4751 }
4752
4753
4754 XS(_wrap_pp_script_name) {
4755   {
4756     pp_script_t *arg1 = (pp_script_t *) 0 ;
4757     void *argp1 = 0 ;
4758     int res1 = 0 ;
4759     int argvi = 0;
4760     char *result = 0 ;
4761     dXSARGS;
4762
4763     if ((items < 1) || (items > 1)) {
4764       SWIG_croak("Usage: pp_script_name(pps);");
4765     }
4766     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_pp_script_t, 0 |  0 );
4767     if (!SWIG_IsOK(res1)) {
4768       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pp_script_name" "', argument " "1"" of type '" "pp_script_t *""'");
4769     }
4770     arg1 = (pp_script_t *)(argp1);
4771     result = (char *)pp_script_name(arg1);
4772     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4773
4774     XSRETURN(argvi);
4775   fail:
4776
4777     SWIG_croak_null();
4778   }
4779 }
4780
4781
4782 XS(_wrap_pp_script_seen) {
4783   {
4784     pp_script_t *arg1 = (pp_script_t *) 0 ;
4785     pp_script_key arg2 ;
4786     void *argp1 = 0 ;
4787     int res1 = 0 ;
4788     int argvi = 0;
4789     gboolean result;
4790     dXSARGS;
4791
4792     if ((items < 2) || (items > 2)) {
4793       SWIG_croak("Usage: pp_script_seen(app,key);");
4794     }
4795     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_pp_script_t, 0 |  0 );
4796     if (!SWIG_IsOK(res1)) {
4797       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pp_script_seen" "', argument " "1"" of type '" "pp_script_t *""'");
4798     }
4799     arg1 = (pp_script_t *)(argp1);
4800     {
4801       if (sizeof(signed int) == 1) {
4802         arg2 = amglue_SvI8(ST(1));
4803       } else if (sizeof(signed int) == 2) {
4804         arg2 = amglue_SvI16(ST(1));
4805       } else if (sizeof(signed int) == 4) {
4806         arg2 = amglue_SvI32(ST(1));
4807       } else if (sizeof(signed int) == 8) {
4808         arg2 = amglue_SvI64(ST(1));
4809       } else {
4810         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4811       }
4812     }
4813     result = (gboolean)pp_script_seen(arg1,arg2);
4814     {
4815       if (result)
4816       ST(argvi) = &PL_sv_yes;
4817       else
4818       ST(argvi) = &PL_sv_no;
4819       argvi++;
4820     }
4821
4822
4823     XSRETURN(argvi);
4824   fail:
4825
4826
4827     SWIG_croak_null();
4828   }
4829 }
4830
4831
4832 XS(_wrap_lookup_device_config) {
4833   {
4834     char *arg1 = (char *) 0 ;
4835     int res1 ;
4836     char *buf1 = 0 ;
4837     int alloc1 = 0 ;
4838     int argvi = 0;
4839     device_config_t *result = 0 ;
4840     dXSARGS;
4841
4842     if ((items < 1) || (items > 1)) {
4843       SWIG_croak("Usage: lookup_device_config(identifier);");
4844     }
4845     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
4846     if (!SWIG_IsOK(res1)) {
4847       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lookup_device_config" "', argument " "1"" of type '" "char *""'");
4848     }
4849     arg1 = (char *)(buf1);
4850     result = (device_config_t *)lookup_device_config(arg1);
4851     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_device_config_t, 0 | 0); argvi++ ;
4852     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4853     XSRETURN(argvi);
4854   fail:
4855     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4856     SWIG_croak_null();
4857   }
4858 }
4859
4860
4861 XS(_wrap_device_config_getconf) {
4862   {
4863     device_config_t *arg1 = (device_config_t *) 0 ;
4864     device_config_key arg2 ;
4865     void *argp1 = 0 ;
4866     int res1 = 0 ;
4867     int argvi = 0;
4868     val_t *result = 0 ;
4869     dXSARGS;
4870
4871     if ((items < 2) || (items > 2)) {
4872       SWIG_croak("Usage: device_config_getconf(pps,key);");
4873     }
4874     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_device_config_t, 0 |  0 );
4875     if (!SWIG_IsOK(res1)) {
4876       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "device_config_getconf" "', argument " "1"" of type '" "device_config_t *""'");
4877     }
4878     arg1 = (device_config_t *)(argp1);
4879     {
4880       if (sizeof(signed int) == 1) {
4881         arg2 = amglue_SvI8(ST(1));
4882       } else if (sizeof(signed int) == 2) {
4883         arg2 = amglue_SvI16(ST(1));
4884       } else if (sizeof(signed int) == 4) {
4885         arg2 = amglue_SvI32(ST(1));
4886       } else if (sizeof(signed int) == 8) {
4887         arg2 = amglue_SvI64(ST(1));
4888       } else {
4889         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4890       }
4891     }
4892     result = (val_t *)device_config_getconf(arg1,arg2);
4893     {
4894       if (!result) {
4895         ST(argvi) = &PL_sv_undef;
4896         argvi++;
4897       } else {
4898         switch (result->type) {
4899           case CONFTYPE_RATE: {
4900             ST(argvi)= sv_newmortal();
4901             sv_setnv(ST(argvi), val_t__rate(result)[0]);
4902             argvi++;
4903
4904             ST(argvi)= sv_newmortal();
4905             sv_setnv(ST(argvi), val_t__rate(result)[1]);
4906             argvi++;
4907             break;
4908           }
4909
4910           case CONFTYPE_INTRANGE: {
4911             ST(argvi)= sv_newmortal();
4912             sv_setiv(ST(argvi), val_t__intrange(result)[0]);
4913             argvi++;
4914
4915             ST(argvi)= sv_newmortal();
4916             sv_setiv(ST(argvi), val_t__intrange(result)[1]);
4917             argvi++;
4918             break;
4919           }
4920
4921           case CONFTYPE_EXINCLUDE: {
4922             /* exincludes are represented in perl as {
4923                          *      'list' : [ 'list1', 'list2', ..],
4924                          *      'file' : [ 'file1', 'file2', ..],
4925                          *      'optional' : 1,
4926                          * }
4927                          */
4928             exinclude_t *ei = &val_t__exinclude(result);
4929             AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
4930             AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
4931             SV *optional = sv_newmortal();
4932             HV *hv;
4933             sle_t *iter;
4934
4935             /* first set up each of the hash values */
4936
4937             if (ei->sl_list) {
4938               for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
4939                 av_push(list_entries, newSVpv(iter->name, 0));
4940               }
4941             }
4942
4943             if(ei->sl_file) {
4944               for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
4945                 av_push(file_entries, newSVpv(iter->name, 0));
4946               }
4947             }
4948
4949             sv_setiv(optional, ei->optional);
4950
4951             /* now build the hash */
4952             hv = (HV *)sv_2mortal((SV *)newHV());
4953
4954             hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
4955             hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
4956             hv_store(hv, "optional", 8, optional, 0);
4957             SvREFCNT_inc(optional);
4958
4959             ST(argvi) = sv_2mortal(newRV((SV *)hv));
4960             argvi++;
4961             break;
4962           }
4963
4964         case CONFTYPE_PROPLIST:
4965           ST(argvi) = sv_2mortal(g_hash_table_to_hashref_property(val_t__proplist(result)));
4966           argvi++;
4967           break;
4968
4969         case CONFTYPE_SIZE:
4970           SP += argvi; PUTBACK;
4971           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
4972           SPAGAIN; SP -= argvi; argvi++;
4973           break;
4974
4975         case CONFTYPE_INT64:
4976           SP += argvi; PUTBACK;
4977           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int64(result)));
4978           SPAGAIN; SP -= argvi; argvi++;
4979           break;
4980
4981           case CONFTYPE_BOOLEAN:            /* all same as INT.. */
4982         case CONFTYPE_COMPRESS:
4983         case CONFTYPE_ENCRYPT:
4984         case CONFTYPE_STRATEGY:
4985         case CONFTYPE_TAPERALGO:
4986         case CONFTYPE_PRIORITY:
4987         case CONFTYPE_HOLDING:
4988         case CONFTYPE_EXECUTE_ON:
4989         case CONFTYPE_EXECUTE_WHERE:
4990         case CONFTYPE_SEND_AMREPORT_ON:
4991         case CONFTYPE_DATA_PATH:
4992         case CONFTYPE_INT:
4993           SP += argvi; PUTBACK;
4994           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
4995           SPAGAIN; SP -= argvi; argvi++;
4996           break;
4997
4998           case CONFTYPE_ESTIMATELIST: {
4999             AV *elist = newAV();
5000             estimatelist_t el;
5001             for (el=val_t__estimatelist(result); el != NULL; el = el->next) {
5002               av_push(elist, newSVuv(GPOINTER_TO_INT(el->data)));
5003             }
5004             ST(argvi) = sv_2mortal(newRV_noinc((SV *)elist));
5005             argvi++;
5006             break;
5007           }
5008
5009         case CONFTYPE_TIME:
5010           SP += argvi; PUTBACK;
5011           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
5012           SPAGAIN; SP -= argvi; argvi++;
5013           break;
5014
5015         case CONFTYPE_REAL:
5016           ST(argvi) = sv_newmortal();
5017           sv_setnv(ST(argvi), val_t__real(result));
5018           argvi++;
5019           break;
5020
5021           case CONFTYPE_IDENT:      /* same as STRING */
5022         case CONFTYPE_STR:
5023         case CONFTYPE_APPLICATION:
5024           ST(argvi) = sv_newmortal();
5025           sv_setpv(ST(argvi), val_t__str(result));
5026           argvi++;
5027           break;
5028
5029           case CONFTYPE_IDENTLIST: {
5030             AV *ilist = newAV();
5031
5032             identlist_t il;
5033             for (il=val_t__identlist(result); il != NULL; il = il->next) {
5034               av_push(ilist, newSVpv((char *)il->data, 0));
5035             }
5036
5037             ST(argvi) = sv_2mortal(newRV_noinc((SV *)ilist));
5038             argvi++;
5039             break;
5040           }
5041
5042           case CONFTYPE_AUTOLABEL: {
5043             autolabel_t *autolabel = &val_t__autolabel(result);
5044             HV *hv;
5045
5046             /* now build the hash */
5047             hv = (HV *)sv_2mortal((SV *)newHV());
5048             hv_store(hv, "template", 8,
5049               (autolabel->template)? newSVpv(autolabel->template, 0) : newSV(0),
5050               0);
5051             hv_store(hv, "other_config", 12,
5052               (autolabel->autolabel & AL_OTHER_CONFIG)? &PL_sv_yes : &PL_sv_no,
5053               0);
5054             hv_store(hv, "non_amanda", 10,
5055               (autolabel->autolabel & AL_NON_AMANDA)? &PL_sv_yes : &PL_sv_no,
5056               0);
5057             hv_store(hv, "volume_error", 12,
5058               (autolabel->autolabel & AL_VOLUME_ERROR)? &PL_sv_yes : &PL_sv_no,
5059               0);
5060             hv_store(hv, "empty", 5,
5061               (autolabel->autolabel & AL_EMPTY)? &PL_sv_yes : &PL_sv_no,
5062               0);
5063
5064             ST(argvi) = sv_2mortal(newRV((SV *)hv));
5065             argvi++;
5066             break;
5067           }
5068
5069           /* No match yet -> not one of the "complex" types */
5070         default:
5071           SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
5072           break;
5073         }
5074       }
5075     }
5076
5077
5078     XSRETURN(argvi);
5079   fail:
5080
5081
5082     SWIG_croak_null();
5083   }
5084 }
5085
5086
5087 XS(_wrap_device_config_name) {
5088   {
5089     device_config_t *arg1 = (device_config_t *) 0 ;
5090     void *argp1 = 0 ;
5091     int res1 = 0 ;
5092     int argvi = 0;
5093     char *result = 0 ;
5094     dXSARGS;
5095
5096     if ((items < 1) || (items > 1)) {
5097       SWIG_croak("Usage: device_config_name(pps);");
5098     }
5099     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_device_config_t, 0 |  0 );
5100     if (!SWIG_IsOK(res1)) {
5101       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "device_config_name" "', argument " "1"" of type '" "device_config_t *""'");
5102     }
5103     arg1 = (device_config_t *)(argp1);
5104     result = (char *)device_config_name(arg1);
5105     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5106
5107     XSRETURN(argvi);
5108   fail:
5109
5110     SWIG_croak_null();
5111   }
5112 }
5113
5114
5115 XS(_wrap_device_config_seen) {
5116   {
5117     device_config_t *arg1 = (device_config_t *) 0 ;
5118     device_config_key arg2 ;
5119     void *argp1 = 0 ;
5120     int res1 = 0 ;
5121     int argvi = 0;
5122     gboolean result;
5123     dXSARGS;
5124
5125     if ((items < 2) || (items > 2)) {
5126       SWIG_croak("Usage: device_config_seen(app,key);");
5127     }
5128     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_device_config_t, 0 |  0 );
5129     if (!SWIG_IsOK(res1)) {
5130       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "device_config_seen" "', argument " "1"" of type '" "device_config_t *""'");
5131     }
5132     arg1 = (device_config_t *)(argp1);
5133     {
5134       if (sizeof(signed int) == 1) {
5135         arg2 = amglue_SvI8(ST(1));
5136       } else if (sizeof(signed int) == 2) {
5137         arg2 = amglue_SvI16(ST(1));
5138       } else if (sizeof(signed int) == 4) {
5139         arg2 = amglue_SvI32(ST(1));
5140       } else if (sizeof(signed int) == 8) {
5141         arg2 = amglue_SvI64(ST(1));
5142       } else {
5143         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5144       }
5145     }
5146     result = (gboolean)device_config_seen(arg1,arg2);
5147     {
5148       if (result)
5149       ST(argvi) = &PL_sv_yes;
5150       else
5151       ST(argvi) = &PL_sv_no;
5152       argvi++;
5153     }
5154
5155
5156     XSRETURN(argvi);
5157   fail:
5158
5159
5160     SWIG_croak_null();
5161   }
5162 }
5163
5164
5165 XS(_wrap_lookup_changer_config) {
5166   {
5167     char *arg1 = (char *) 0 ;
5168     int res1 ;
5169     char *buf1 = 0 ;
5170     int alloc1 = 0 ;
5171     int argvi = 0;
5172     changer_config_t *result = 0 ;
5173     dXSARGS;
5174
5175     if ((items < 1) || (items > 1)) {
5176       SWIG_croak("Usage: lookup_changer_config(identifier);");
5177     }
5178     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
5179     if (!SWIG_IsOK(res1)) {
5180       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lookup_changer_config" "', argument " "1"" of type '" "char *""'");
5181     }
5182     arg1 = (char *)(buf1);
5183     result = (changer_config_t *)lookup_changer_config(arg1);
5184     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_changer_config_t, 0 | 0); argvi++ ;
5185     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5186     XSRETURN(argvi);
5187   fail:
5188     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5189     SWIG_croak_null();
5190   }
5191 }
5192
5193
5194 XS(_wrap_changer_config_getconf) {
5195   {
5196     changer_config_t *arg1 = (changer_config_t *) 0 ;
5197     changer_config_key arg2 ;
5198     void *argp1 = 0 ;
5199     int res1 = 0 ;
5200     int argvi = 0;
5201     val_t *result = 0 ;
5202     dXSARGS;
5203
5204     if ((items < 2) || (items > 2)) {
5205       SWIG_croak("Usage: changer_config_getconf(pps,key);");
5206     }
5207     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_changer_config_t, 0 |  0 );
5208     if (!SWIG_IsOK(res1)) {
5209       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "changer_config_getconf" "', argument " "1"" of type '" "changer_config_t *""'");
5210     }
5211     arg1 = (changer_config_t *)(argp1);
5212     {
5213       if (sizeof(signed int) == 1) {
5214         arg2 = amglue_SvI8(ST(1));
5215       } else if (sizeof(signed int) == 2) {
5216         arg2 = amglue_SvI16(ST(1));
5217       } else if (sizeof(signed int) == 4) {
5218         arg2 = amglue_SvI32(ST(1));
5219       } else if (sizeof(signed int) == 8) {
5220         arg2 = amglue_SvI64(ST(1));
5221       } else {
5222         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5223       }
5224     }
5225     result = (val_t *)changer_config_getconf(arg1,arg2);
5226     {
5227       if (!result) {
5228         ST(argvi) = &PL_sv_undef;
5229         argvi++;
5230       } else {
5231         switch (result->type) {
5232           case CONFTYPE_RATE: {
5233             ST(argvi)= sv_newmortal();
5234             sv_setnv(ST(argvi), val_t__rate(result)[0]);
5235             argvi++;
5236
5237             ST(argvi)= sv_newmortal();
5238             sv_setnv(ST(argvi), val_t__rate(result)[1]);
5239             argvi++;
5240             break;
5241           }
5242
5243           case CONFTYPE_INTRANGE: {
5244             ST(argvi)= sv_newmortal();
5245             sv_setiv(ST(argvi), val_t__intrange(result)[0]);
5246             argvi++;
5247
5248             ST(argvi)= sv_newmortal();
5249             sv_setiv(ST(argvi), val_t__intrange(result)[1]);
5250             argvi++;
5251             break;
5252           }
5253
5254           case CONFTYPE_EXINCLUDE: {
5255             /* exincludes are represented in perl as {
5256                          *      'list' : [ 'list1', 'list2', ..],
5257                          *      'file' : [ 'file1', 'file2', ..],
5258                          *      'optional' : 1,
5259                          * }
5260                          */
5261             exinclude_t *ei = &val_t__exinclude(result);
5262             AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
5263             AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
5264             SV *optional = sv_newmortal();
5265             HV *hv;
5266             sle_t *iter;
5267
5268             /* first set up each of the hash values */
5269
5270             if (ei->sl_list) {
5271               for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
5272                 av_push(list_entries, newSVpv(iter->name, 0));
5273               }
5274             }
5275
5276             if(ei->sl_file) {
5277               for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
5278                 av_push(file_entries, newSVpv(iter->name, 0));
5279               }
5280             }
5281
5282             sv_setiv(optional, ei->optional);
5283
5284             /* now build the hash */
5285             hv = (HV *)sv_2mortal((SV *)newHV());
5286
5287             hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
5288             hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
5289             hv_store(hv, "optional", 8, optional, 0);
5290             SvREFCNT_inc(optional);
5291
5292             ST(argvi) = sv_2mortal(newRV((SV *)hv));
5293             argvi++;
5294             break;
5295           }
5296
5297         case CONFTYPE_PROPLIST:
5298           ST(argvi) = sv_2mortal(g_hash_table_to_hashref_property(val_t__proplist(result)));
5299           argvi++;
5300           break;
5301
5302         case CONFTYPE_SIZE:
5303           SP += argvi; PUTBACK;
5304           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
5305           SPAGAIN; SP -= argvi; argvi++;
5306           break;
5307
5308         case CONFTYPE_INT64:
5309           SP += argvi; PUTBACK;
5310           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int64(result)));
5311           SPAGAIN; SP -= argvi; argvi++;
5312           break;
5313
5314           case CONFTYPE_BOOLEAN:            /* all same as INT.. */
5315         case CONFTYPE_COMPRESS:
5316         case CONFTYPE_ENCRYPT:
5317         case CONFTYPE_STRATEGY:
5318         case CONFTYPE_TAPERALGO:
5319         case CONFTYPE_PRIORITY:
5320         case CONFTYPE_HOLDING:
5321         case CONFTYPE_EXECUTE_ON:
5322         case CONFTYPE_EXECUTE_WHERE:
5323         case CONFTYPE_SEND_AMREPORT_ON:
5324         case CONFTYPE_DATA_PATH:
5325         case CONFTYPE_INT:
5326           SP += argvi; PUTBACK;
5327           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
5328           SPAGAIN; SP -= argvi; argvi++;
5329           break;
5330
5331           case CONFTYPE_ESTIMATELIST: {
5332             AV *elist = newAV();
5333             estimatelist_t el;
5334             for (el=val_t__estimatelist(result); el != NULL; el = el->next) {
5335               av_push(elist, newSVuv(GPOINTER_TO_INT(el->data)));
5336             }
5337             ST(argvi) = sv_2mortal(newRV_noinc((SV *)elist));
5338             argvi++;
5339             break;
5340           }
5341
5342         case CONFTYPE_TIME:
5343           SP += argvi; PUTBACK;
5344           ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
5345           SPAGAIN; SP -= argvi; argvi++;
5346           break;
5347
5348         case CONFTYPE_REAL:
5349           ST(argvi) = sv_newmortal();
5350           sv_setnv(ST(argvi), val_t__real(result));
5351           argvi++;
5352           break;
5353
5354           case CONFTYPE_IDENT:      /* same as STRING */
5355         case CONFTYPE_STR:
5356         case CONFTYPE_APPLICATION:
5357           ST(argvi) = sv_newmortal();
5358           sv_setpv(ST(argvi), val_t__str(result));
5359           argvi++;
5360           break;
5361
5362           case CONFTYPE_IDENTLIST: {
5363             AV *ilist = newAV();
5364
5365             identlist_t il;
5366             for (il=val_t__identlist(result); il != NULL; il = il->next) {
5367               av_push(ilist, newSVpv((char *)il->data, 0));
5368             }
5369
5370             ST(argvi) = sv_2mortal(newRV_noinc((SV *)ilist));
5371             argvi++;
5372             break;
5373           }
5374
5375           case CONFTYPE_AUTOLABEL: {
5376             autolabel_t *autolabel = &val_t__autolabel(result);
5377             HV *hv;
5378
5379             /* now build the hash */
5380             hv = (HV *)sv_2mortal((SV *)newHV());
5381             hv_store(hv, "template", 8,
5382               (autolabel->template)? newSVpv(autolabel->template, 0) : newSV(0),
5383               0);
5384             hv_store(hv, "other_config", 12,
5385               (autolabel->autolabel & AL_OTHER_CONFIG)? &PL_sv_yes : &PL_sv_no,
5386               0);
5387             hv_store(hv, "non_amanda", 10,
5388               (autolabel->autolabel & AL_NON_AMANDA)? &PL_sv_yes : &PL_sv_no,
5389               0);
5390             hv_store(hv, "volume_error", 12,
5391               (autolabel->autolabel & AL_VOLUME_ERROR)? &PL_sv_yes : &PL_sv_no,
5392               0);
5393             hv_store(hv, "empty", 5,
5394               (autolabel->autolabel & AL_EMPTY)? &PL_sv_yes : &PL_sv_no,
5395               0);
5396
5397             ST(argvi) = sv_2mortal(newRV((SV *)hv));
5398             argvi++;
5399             break;
5400           }
5401
5402           /* No match yet -> not one of the "complex" types */
5403         default:
5404           SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
5405           break;
5406         }
5407       }
5408     }
5409
5410
5411     XSRETURN(argvi);
5412   fail:
5413
5414
5415     SWIG_croak_null();
5416   }
5417 }
5418
5419
5420 XS(_wrap_changer_config_name) {
5421   {
5422     changer_config_t *arg1 = (changer_config_t *) 0 ;
5423     void *argp1 = 0 ;
5424     int res1 = 0 ;
5425     int argvi = 0;
5426     char *result = 0 ;
5427     dXSARGS;
5428
5429     if ((items < 1) || (items > 1)) {
5430       SWIG_croak("Usage: changer_config_name(pps);");
5431     }
5432     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_changer_config_t, 0 |  0 );
5433     if (!SWIG_IsOK(res1)) {
5434       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "changer_config_name" "', argument " "1"" of type '" "changer_config_t *""'");
5435     }
5436     arg1 = (changer_config_t *)(argp1);
5437     result = (char *)changer_config_name(arg1);
5438     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5439
5440     XSRETURN(argvi);
5441   fail:
5442
5443     SWIG_croak_null();
5444   }
5445 }
5446
5447
5448 XS(_wrap_changer_config_seen) {
5449   {
5450     changer_config_t *arg1 = (changer_config_t *) 0 ;
5451     changer_config_key arg2 ;
5452     void *argp1 = 0 ;
5453     int res1 = 0 ;
5454     int argvi = 0;
5455     gboolean result;
5456     dXSARGS;
5457
5458     if ((items < 2) || (items > 2)) {
5459       SWIG_croak("Usage: changer_config_seen(app,key);");
5460     }
5461     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_changer_config_t, 0 |  0 );
5462     if (!SWIG_IsOK(res1)) {
5463       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "changer_config_seen" "', argument " "1"" of type '" "changer_config_t *""'");
5464     }
5465     arg1 = (changer_config_t *)(argp1);
5466     {
5467       if (sizeof(signed int) == 1) {
5468         arg2 = amglue_SvI8(ST(1));
5469       } else if (sizeof(signed int) == 2) {
5470         arg2 = amglue_SvI16(ST(1));
5471       } else if (sizeof(signed int) == 4) {
5472         arg2 = amglue_SvI32(ST(1));
5473       } else if (sizeof(signed int) == 8) {
5474         arg2 = amglue_SvI64(ST(1));
5475       } else {
5476         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5477       }
5478     }
5479     result = (gboolean)changer_config_seen(arg1,arg2);
5480     {
5481       if (result)
5482       ST(argvi) = &PL_sv_yes;
5483       else
5484       ST(argvi) = &PL_sv_no;
5485       argvi++;
5486     }
5487
5488
5489     XSRETURN(argvi);
5490   fail:
5491
5492
5493     SWIG_croak_null();
5494   }
5495 }
5496
5497
5498 XS(_wrap_getconf_unit_divisor) {
5499   {
5500     int argvi = 0;
5501     long result;
5502     dXSARGS;
5503
5504     if ((items < 0) || (items > 0)) {
5505       SWIG_croak("Usage: getconf_unit_divisor();");
5506     }
5507     result = (long)getconf_unit_divisor();
5508     {
5509       SV *for_stack;
5510       SP += argvi; PUTBACK;
5511       for_stack = sv_2mortal(amglue_newSVi64(result));
5512       SPAGAIN; SP -= argvi;
5513       ST(argvi) = for_stack;
5514       argvi++;
5515     }
5516     XSRETURN(argvi);
5517   fail:
5518     SWIG_croak_null();
5519   }
5520 }
5521
5522
5523 XS(_wrap_config_init) {
5524   {
5525     config_init_flags arg1 ;
5526     char *arg2 = (char *) 0 ;
5527     int res2 ;
5528     char *buf2 = 0 ;
5529     int alloc2 = 0 ;
5530     int argvi = 0;
5531     cfgerr_level_t result;
5532     dXSARGS;
5533
5534     if ((items < 2) || (items > 2)) {
5535       SWIG_croak("Usage: config_init(flags,arg_config_name);");
5536     }
5537     {
5538       if (sizeof(signed int) == 1) {
5539         arg1 = amglue_SvI8(ST(0));
5540       } else if (sizeof(signed int) == 2) {
5541         arg1 = amglue_SvI16(ST(0));
5542       } else if (sizeof(signed int) == 4) {
5543         arg1 = amglue_SvI32(ST(0));
5544       } else if (sizeof(signed int) == 8) {
5545         arg1 = amglue_SvI64(ST(0));
5546       } else {
5547         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5548       }
5549     }
5550     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5551     if (!SWIG_IsOK(res2)) {
5552       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "config_init" "', argument " "2"" of type '" "char *""'");
5553     }
5554     arg2 = (char *)(buf2);
5555     result = (cfgerr_level_t)config_init(arg1,arg2);
5556     {
5557       SV *for_stack;
5558       SP += argvi; PUTBACK;
5559       for_stack = sv_2mortal(amglue_newSVi64(result));
5560       SPAGAIN; SP -= argvi;
5561       ST(argvi) = for_stack;
5562       argvi++;
5563     }
5564
5565     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5566     XSRETURN(argvi);
5567   fail:
5568
5569     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5570     SWIG_croak_null();
5571   }
5572 }
5573
5574
5575 XS(_wrap_config_uninit) {
5576   {
5577     int argvi = 0;
5578     dXSARGS;
5579
5580     if ((items < 0) || (items > 0)) {
5581       SWIG_croak("Usage: config_uninit();");
5582     }
5583     config_uninit();
5584     ST(argvi) = sv_newmortal();
5585     XSRETURN(argvi);
5586   fail:
5587     SWIG_croak_null();
5588   }
5589 }
5590
5591
5592 XS(_wrap_get_config_options) {
5593   {
5594     int arg1 ;
5595     int argvi = 0;
5596     char **result = 0 ;
5597     dXSARGS;
5598
5599     if ((items < 1) || (items > 1)) {
5600       SWIG_croak("Usage: get_config_options(first);");
5601     }
5602     {
5603       if (sizeof(signed int) == 1) {
5604         arg1 = amglue_SvI8(ST(0));
5605       } else if (sizeof(signed int) == 2) {
5606         arg1 = amglue_SvI16(ST(0));
5607       } else if (sizeof(signed int) == 4) {
5608         arg1 = amglue_SvI32(ST(0));
5609       } else if (sizeof(signed int) == 8) {
5610         arg1 = amglue_SvI64(ST(0));
5611       } else {
5612         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5613       }
5614     }
5615     result = (char **)get_config_options(arg1);
5616     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_char, 0 | 0); argvi++ ;
5617
5618     XSRETURN(argvi);
5619   fail:
5620
5621     SWIG_croak_null();
5622   }
5623 }
5624
5625
5626 XS(_wrap_get_config_name) {
5627   {
5628     int argvi = 0;
5629     char *result = 0 ;
5630     dXSARGS;
5631
5632     if ((items < 0) || (items > 0)) {
5633       SWIG_croak("Usage: get_config_name();");
5634     }
5635     result = (char *)get_config_name();
5636     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5637     XSRETURN(argvi);
5638   fail:
5639     SWIG_croak_null();
5640   }
5641 }
5642
5643
5644 XS(_wrap_get_config_dir) {
5645   {
5646     int argvi = 0;
5647     char *result = 0 ;
5648     dXSARGS;
5649
5650     if ((items < 0) || (items > 0)) {
5651       SWIG_croak("Usage: get_config_dir();");
5652     }
5653     result = (char *)get_config_dir();
5654     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5655     XSRETURN(argvi);
5656   fail:
5657     SWIG_croak_null();
5658   }
5659 }
5660
5661
5662 XS(_wrap_get_config_filename) {
5663   {
5664     int argvi = 0;
5665     char *result = 0 ;
5666     dXSARGS;
5667
5668     if ((items < 0) || (items > 0)) {
5669       SWIG_croak("Usage: get_config_filename();");
5670     }
5671     result = (char *)get_config_filename();
5672     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5673     XSRETURN(argvi);
5674   fail:
5675     SWIG_croak_null();
5676   }
5677 }
5678
5679
5680 XS(_wrap_config_print_errors) {
5681   {
5682     int argvi = 0;
5683     dXSARGS;
5684
5685     if ((items < 0) || (items > 0)) {
5686       SWIG_croak("Usage: config_print_errors();");
5687     }
5688     config_print_errors();
5689     ST(argvi) = sv_newmortal();
5690     XSRETURN(argvi);
5691   fail:
5692     SWIG_croak_null();
5693   }
5694 }
5695
5696
5697 XS(_wrap_config_clear_errors) {
5698   {
5699     int argvi = 0;
5700     dXSARGS;
5701
5702     if ((items < 0) || (items > 0)) {
5703       SWIG_croak("Usage: config_clear_errors();");
5704     }
5705     config_clear_errors();
5706     ST(argvi) = sv_newmortal();
5707     XSRETURN(argvi);
5708   fail:
5709     SWIG_croak_null();
5710   }
5711 }
5712
5713
5714 XS(_wrap_config_errors) {
5715   {
5716     GSList **arg1 = (GSList **) 0 ;
5717     GSList *templist1 ;
5718     int argvi = 0;
5719     cfgerr_level_t result;
5720     dXSARGS;
5721
5722     {
5723       templist1 = NULL;
5724       arg1 = &templist1;
5725     }
5726     if ((items < 0) || (items > 0)) {
5727       SWIG_croak("Usage: config_errors();");
5728     }
5729     result = (cfgerr_level_t)config_errors(arg1);
5730     {
5731       SV *for_stack;
5732       SP += argvi; PUTBACK;
5733       for_stack = sv_2mortal(amglue_newSVi64(result));
5734       SPAGAIN; SP -= argvi;
5735       ST(argvi) = for_stack;
5736       argvi++;
5737     }
5738     {
5739       GSList *it = *arg1;
5740
5741       while (it) {
5742         ST(argvi) = sv_2mortal(newSVpv(it->data, 0));
5743         argvi++;
5744         it = it->next;
5745       }
5746     }
5747
5748     XSRETURN(argvi);
5749   fail:
5750
5751     SWIG_croak_null();
5752   }
5753 }
5754
5755
5756 XS(_wrap_new_config_overrides) {
5757   {
5758     int arg1 ;
5759     int argvi = 0;
5760     config_overrides_t *result = 0 ;
5761     dXSARGS;
5762
5763     if ((items < 1) || (items > 1)) {
5764       SWIG_croak("Usage: new_config_overrides(size_estimate);");
5765     }
5766     {
5767       if (sizeof(signed int) == 1) {
5768         arg1 = amglue_SvI8(ST(0));
5769       } else if (sizeof(signed int) == 2) {
5770         arg1 = amglue_SvI16(ST(0));
5771       } else if (sizeof(signed int) == 4) {
5772         arg1 = amglue_SvI32(ST(0));
5773       } else if (sizeof(signed int) == 8) {
5774         arg1 = amglue_SvI64(ST(0));
5775       } else {
5776         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5777       }
5778     }
5779     result = (config_overrides_t *)new_config_overrides(arg1);
5780     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_config_overrides_t, 0 | 0); argvi++ ;
5781
5782     XSRETURN(argvi);
5783   fail:
5784
5785     SWIG_croak_null();
5786   }
5787 }
5788
5789
5790 XS(_wrap_free_config_overrides) {
5791   {
5792     config_overrides_t *arg1 = (config_overrides_t *) 0 ;
5793     void *argp1 = 0 ;
5794     int res1 = 0 ;
5795     int argvi = 0;
5796     dXSARGS;
5797
5798     if ((items < 1) || (items > 1)) {
5799       SWIG_croak("Usage: free_config_overrides(co);");
5800     }
5801     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_config_overrides_t, 0 |  0 );
5802     if (!SWIG_IsOK(res1)) {
5803       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_config_overrides" "', argument " "1"" of type '" "config_overrides_t *""'");
5804     }
5805     arg1 = (config_overrides_t *)(argp1);
5806     free_config_overrides(arg1);
5807     ST(argvi) = sv_newmortal();
5808
5809     XSRETURN(argvi);
5810   fail:
5811
5812     SWIG_croak_null();
5813   }
5814 }
5815
5816
5817 XS(_wrap_add_config_override) {
5818   {
5819     config_overrides_t *arg1 = (config_overrides_t *) 0 ;
5820     char *arg2 = (char *) 0 ;
5821     char *arg3 = (char *) 0 ;
5822     void *argp1 = 0 ;
5823     int res1 = 0 ;
5824     int res2 ;
5825     char *buf2 = 0 ;
5826     int alloc2 = 0 ;
5827     int res3 ;
5828     char *buf3 = 0 ;
5829     int alloc3 = 0 ;
5830     int argvi = 0;
5831     dXSARGS;
5832
5833     if ((items < 3) || (items > 3)) {
5834       SWIG_croak("Usage: add_config_override(co,key,value);");
5835     }
5836     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_config_overrides_t, 0 |  0 );
5837     if (!SWIG_IsOK(res1)) {
5838       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "add_config_override" "', argument " "1"" of type '" "config_overrides_t *""'");
5839     }
5840     arg1 = (config_overrides_t *)(argp1);
5841     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5842     if (!SWIG_IsOK(res2)) {
5843       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "add_config_override" "', argument " "2"" of type '" "char *""'");
5844     }
5845     arg2 = (char *)(buf2);
5846     res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
5847     if (!SWIG_IsOK(res3)) {
5848       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "add_config_override" "', argument " "3"" of type '" "char *""'");
5849     }
5850     arg3 = (char *)(buf3);
5851     add_config_override(arg1,arg2,arg3);
5852     ST(argvi) = sv_newmortal();
5853
5854     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5855     if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5856     XSRETURN(argvi);
5857   fail:
5858
5859     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5860     if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
5861     SWIG_croak_null();
5862   }
5863 }
5864
5865
5866 XS(_wrap_add_config_override_opt) {
5867   {
5868     config_overrides_t *arg1 = (config_overrides_t *) 0 ;
5869     char *arg2 = (char *) 0 ;
5870     void *argp1 = 0 ;
5871     int res1 = 0 ;
5872     int res2 ;
5873     char *buf2 = 0 ;
5874     int alloc2 = 0 ;
5875     int argvi = 0;
5876     dXSARGS;
5877
5878     if ((items < 2) || (items > 2)) {
5879       SWIG_croak("Usage: add_config_override_opt(co,optarg);");
5880     }
5881     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_config_overrides_t, 0 |  0 );
5882     if (!SWIG_IsOK(res1)) {
5883       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "add_config_override_opt" "', argument " "1"" of type '" "config_overrides_t *""'");
5884     }
5885     arg1 = (config_overrides_t *)(argp1);
5886     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5887     if (!SWIG_IsOK(res2)) {
5888       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "add_config_override_opt" "', argument " "2"" of type '" "char *""'");
5889     }
5890     arg2 = (char *)(buf2);
5891     add_config_override_opt(arg1,arg2);
5892     ST(argvi) = sv_newmortal();
5893
5894     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5895     XSRETURN(argvi);
5896   fail:
5897
5898     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5899     SWIG_croak_null();
5900   }
5901 }
5902
5903
5904 XS(_wrap_set_config_overrides) {
5905   {
5906     config_overrides_t *arg1 = (config_overrides_t *) 0 ;
5907     void *argp1 = 0 ;
5908     int res1 = 0 ;
5909     int argvi = 0;
5910     dXSARGS;
5911
5912     if ((items < 1) || (items > 1)) {
5913       SWIG_croak("Usage: set_config_overrides(co);");
5914     }
5915     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_config_overrides_t, 0 |  0 );
5916     if (!SWIG_IsOK(res1)) {
5917       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "set_config_overrides" "', argument " "1"" of type '" "config_overrides_t *""'");
5918     }
5919     arg1 = (config_overrides_t *)(argp1);
5920     set_config_overrides(arg1);
5921     ST(argvi) = sv_newmortal();
5922
5923     XSRETURN(argvi);
5924   fail:
5925
5926     SWIG_croak_null();
5927   }
5928 }
5929
5930
5931 XS(_wrap_dump_configuration) {
5932   {
5933     int argvi = 0;
5934     dXSARGS;
5935
5936     if ((items < 0) || (items > 0)) {
5937       SWIG_croak("Usage: dump_configuration();");
5938     }
5939     dump_configuration();
5940     ST(argvi) = sv_newmortal();
5941     XSRETURN(argvi);
5942   fail:
5943     SWIG_croak_null();
5944   }
5945 }
5946
5947
5948 XS(_wrap_config_dir_relative) {
5949   {
5950     char *arg1 = (char *) 0 ;
5951     int res1 ;
5952     char *buf1 = 0 ;
5953     int alloc1 = 0 ;
5954     int argvi = 0;
5955     char *result = 0 ;
5956     dXSARGS;
5957
5958     if ((items < 1) || (items > 1)) {
5959       SWIG_croak("Usage: config_dir_relative(filename);");
5960     }
5961     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
5962     if (!SWIG_IsOK(res1)) {
5963       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "config_dir_relative" "', argument " "1"" of type '" "char *""'");
5964     }
5965     arg1 = (char *)(buf1);
5966     result = (char *)config_dir_relative(arg1);
5967     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5968     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5969     free((char*)result);
5970     XSRETURN(argvi);
5971   fail:
5972     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
5973     SWIG_croak_null();
5974   }
5975 }
5976
5977
5978 XS(_wrap_taperalgo2str) {
5979   {
5980     taperalgo_t arg1 ;
5981     int argvi = 0;
5982     char *result = 0 ;
5983     dXSARGS;
5984
5985     if ((items < 1) || (items > 1)) {
5986       SWIG_croak("Usage: taperalgo2str(taperalgo);");
5987     }
5988     {
5989       if (sizeof(signed int) == 1) {
5990         arg1 = amglue_SvI8(ST(0));
5991       } else if (sizeof(signed int) == 2) {
5992         arg1 = amglue_SvI16(ST(0));
5993       } else if (sizeof(signed int) == 4) {
5994         arg1 = amglue_SvI32(ST(0));
5995       } else if (sizeof(signed int) == 8) {
5996         arg1 = amglue_SvI64(ST(0));
5997       } else {
5998         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5999       }
6000     }
6001     result = (char *)taperalgo2str(arg1);
6002     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
6003
6004     XSRETURN(argvi);
6005   fail:
6006
6007     SWIG_croak_null();
6008   }
6009 }
6010
6011
6012 XS(_wrap_find_multiplier) {
6013   {
6014     char *arg1 = (char *) 0 ;
6015     int res1 ;
6016     char *buf1 = 0 ;
6017     int alloc1 = 0 ;
6018     int argvi = 0;
6019     gint64 result;
6020     dXSARGS;
6021
6022     if ((items < 1) || (items > 1)) {
6023       SWIG_croak("Usage: find_multiplier(casestr);");
6024     }
6025     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
6026     if (!SWIG_IsOK(res1)) {
6027       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "find_multiplier" "', argument " "1"" of type '" "char *""'");
6028     }
6029     arg1 = (char *)(buf1);
6030     result = find_multiplier(arg1);
6031     {
6032       SV *for_stack;
6033       SP += argvi; PUTBACK;
6034       for_stack = sv_2mortal(amglue_newSVi64(result));
6035       SPAGAIN; SP -= argvi;
6036       ST(argvi) = for_stack;
6037       argvi++;
6038     }
6039     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6040     XSRETURN(argvi);
6041   fail:
6042     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6043     SWIG_croak_null();
6044   }
6045 }
6046
6047
6048 XS(_wrap_C_string_to_boolean) {
6049   {
6050     char *arg1 = (char *) 0 ;
6051     int res1 ;
6052     char *buf1 = 0 ;
6053     int alloc1 = 0 ;
6054     int argvi = 0;
6055     int result;
6056     dXSARGS;
6057
6058     if ((items < 1) || (items > 1)) {
6059       SWIG_croak("Usage: C_string_to_boolean(str);");
6060     }
6061     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
6062     if (!SWIG_IsOK(res1)) {
6063       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "C_string_to_boolean" "', argument " "1"" of type '" "char const *""'");
6064     }
6065     arg1 = (char *)(buf1);
6066     result = (int)string_to_boolean((char const *)arg1);
6067     {
6068       SV *for_stack;
6069       SP += argvi; PUTBACK;
6070       for_stack = sv_2mortal(amglue_newSVi64(result));
6071       SPAGAIN; SP -= argvi;
6072       ST(argvi) = for_stack;
6073       argvi++;
6074     }
6075     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6076     XSRETURN(argvi);
6077   fail:
6078     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6079     SWIG_croak_null();
6080   }
6081 }
6082
6083
6084
6085 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6086
6087 static swig_type_info _swigt__p_application_t = {"_p_application_t", "application_t *", 0, 0, (void*)0, 0};
6088 static swig_type_info _swigt__p_changer_config_t = {"_p_changer_config_t", "changer_config_t *", 0, 0, (void*)0, 0};
6089 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
6090 static swig_type_info _swigt__p_config_overrides_t = {"_p_config_overrides_t", "config_overrides_t *", 0, 0, (void*)0, 0};
6091 static swig_type_info _swigt__p_device_config_t = {"_p_device_config_t", "device_config_t *", 0, 0, (void*)0, 0};
6092 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
6093 static swig_type_info _swigt__p_dumptype_t = {"_p_dumptype_t", "dumptype_t *", 0, 0, (void*)0, 0};
6094 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
6095 static swig_type_info _swigt__p_holdingdisk_t = {"_p_holdingdisk_t", "holdingdisk_t *", 0, 0, (void*)0, 0};
6096 static swig_type_info _swigt__p_int = {"_p_int", "application_key *|strategy_t *|pp_script_key *|int *|autolabel_enum_t *|comp_t *|dump_holdingdisk_t *|device_config_key *|changer_config_key *|confparm_key *|interface_key *|holdingdisk_key *|dumptype_key *|tapetype_key *|cfgerr_level_t *|encrypt_t *|taperalgo_t *|gboolean *|data_path_t *|execute_on_t *|send_amreport_on_t *|estimate_t *|config_init_flags *", 0, 0, (void*)0, 0};
6097 static swig_type_info _swigt__p_interface_t = {"_p_interface_t", "interface_t *", 0, 0, (void*)0, 0};
6098 static swig_type_info _swigt__p_p_GSList = {"_p_p_GSList", "GSList **", 0, 0, (void*)0, 0};
6099 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
6100 static swig_type_info _swigt__p_pp_script_t = {"_p_pp_script_t", "pp_script_t *", 0, 0, (void*)0, 0};
6101 static swig_type_info _swigt__p_tapetype_t = {"_p_tapetype_t", "tapetype_t *", 0, 0, (void*)0, 0};
6102 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
6103
6104 static swig_type_info *swig_type_initial[] = {
6105   &_swigt__p_application_t,
6106   &_swigt__p_changer_config_t,
6107   &_swigt__p_char,
6108   &_swigt__p_config_overrides_t,
6109   &_swigt__p_device_config_t,
6110   &_swigt__p_double,
6111   &_swigt__p_dumptype_t,
6112   &_swigt__p_float,
6113   &_swigt__p_holdingdisk_t,
6114   &_swigt__p_int,
6115   &_swigt__p_interface_t,
6116   &_swigt__p_p_GSList,
6117   &_swigt__p_p_char,
6118   &_swigt__p_pp_script_t,
6119   &_swigt__p_tapetype_t,
6120   &_swigt__p_unsigned_char,
6121 };
6122
6123 static swig_cast_info _swigc__p_application_t[] = {  {&_swigt__p_application_t, 0, 0, 0},{0, 0, 0, 0}};
6124 static swig_cast_info _swigc__p_changer_config_t[] = {  {&_swigt__p_changer_config_t, 0, 0, 0},{0, 0, 0, 0}};
6125 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
6126 static swig_cast_info _swigc__p_config_overrides_t[] = {  {&_swigt__p_config_overrides_t, 0, 0, 0},{0, 0, 0, 0}};
6127 static swig_cast_info _swigc__p_device_config_t[] = {  {&_swigt__p_device_config_t, 0, 0, 0},{0, 0, 0, 0}};
6128 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
6129 static swig_cast_info _swigc__p_dumptype_t[] = {  {&_swigt__p_dumptype_t, 0, 0, 0},{0, 0, 0, 0}};
6130 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
6131 static swig_cast_info _swigc__p_holdingdisk_t[] = {  {&_swigt__p_holdingdisk_t, 0, 0, 0},{0, 0, 0, 0}};
6132 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
6133 static swig_cast_info _swigc__p_interface_t[] = {  {&_swigt__p_interface_t, 0, 0, 0},{0, 0, 0, 0}};
6134 static swig_cast_info _swigc__p_p_GSList[] = {  {&_swigt__p_p_GSList, 0, 0, 0},{0, 0, 0, 0}};
6135 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
6136 static swig_cast_info _swigc__p_pp_script_t[] = {  {&_swigt__p_pp_script_t, 0, 0, 0},{0, 0, 0, 0}};
6137 static swig_cast_info _swigc__p_tapetype_t[] = {  {&_swigt__p_tapetype_t, 0, 0, 0},{0, 0, 0, 0}};
6138 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
6139
6140 static swig_cast_info *swig_cast_initial[] = {
6141   _swigc__p_application_t,
6142   _swigc__p_changer_config_t,
6143   _swigc__p_char,
6144   _swigc__p_config_overrides_t,
6145   _swigc__p_device_config_t,
6146   _swigc__p_double,
6147   _swigc__p_dumptype_t,
6148   _swigc__p_float,
6149   _swigc__p_holdingdisk_t,
6150   _swigc__p_int,
6151   _swigc__p_interface_t,
6152   _swigc__p_p_GSList,
6153   _swigc__p_p_char,
6154   _swigc__p_pp_script_t,
6155   _swigc__p_tapetype_t,
6156   _swigc__p_unsigned_char,
6157 };
6158
6159
6160 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6161
6162 static swig_constant_info swig_constants[] = {
6163 {0,0,0,0,0,0}
6164 };
6165 #ifdef __cplusplus
6166 }
6167 #endif
6168 static swig_variable_info swig_variables[] = {
6169     { "Amanda::Configc::debug_amandad", MAGIC_CLASS _wrap_debug_amandad_set, MAGIC_CLASS _wrap_debug_amandad_get,0 },
6170     { "Amanda::Configc::debug_recovery", MAGIC_CLASS _wrap_debug_recovery_set, MAGIC_CLASS _wrap_debug_recovery_get,0 },
6171     { "Amanda::Configc::debug_amidxtaped", MAGIC_CLASS _wrap_debug_amidxtaped_set, MAGIC_CLASS _wrap_debug_amidxtaped_get,0 },
6172     { "Amanda::Configc::debug_amindexd", MAGIC_CLASS _wrap_debug_amindexd_set, MAGIC_CLASS _wrap_debug_amindexd_get,0 },
6173     { "Amanda::Configc::debug_amrecover", MAGIC_CLASS _wrap_debug_amrecover_set, MAGIC_CLASS _wrap_debug_amrecover_get,0 },
6174     { "Amanda::Configc::debug_auth", MAGIC_CLASS _wrap_debug_auth_set, MAGIC_CLASS _wrap_debug_auth_get,0 },
6175     { "Amanda::Configc::debug_event", MAGIC_CLASS _wrap_debug_event_set, MAGIC_CLASS _wrap_debug_event_get,0 },
6176     { "Amanda::Configc::debug_holding", MAGIC_CLASS _wrap_debug_holding_set, MAGIC_CLASS _wrap_debug_holding_get,0 },
6177     { "Amanda::Configc::debug_protocol", MAGIC_CLASS _wrap_debug_protocol_set, MAGIC_CLASS _wrap_debug_protocol_get,0 },
6178     { "Amanda::Configc::debug_planner", MAGIC_CLASS _wrap_debug_planner_set, MAGIC_CLASS _wrap_debug_planner_get,0 },
6179     { "Amanda::Configc::debug_driver", MAGIC_CLASS _wrap_debug_driver_set, MAGIC_CLASS _wrap_debug_driver_get,0 },
6180     { "Amanda::Configc::debug_dumper", MAGIC_CLASS _wrap_debug_dumper_set, MAGIC_CLASS _wrap_debug_dumper_get,0 },
6181     { "Amanda::Configc::debug_chunker", MAGIC_CLASS _wrap_debug_chunker_set, MAGIC_CLASS _wrap_debug_chunker_get,0 },
6182     { "Amanda::Configc::debug_taper", MAGIC_CLASS _wrap_debug_taper_set, MAGIC_CLASS _wrap_debug_taper_get,0 },
6183     { "Amanda::Configc::debug_selfcheck", MAGIC_CLASS _wrap_debug_selfcheck_set, MAGIC_CLASS _wrap_debug_selfcheck_get,0 },
6184     { "Amanda::Configc::debug_sendsize", MAGIC_CLASS _wrap_debug_sendsize_set, MAGIC_CLASS _wrap_debug_sendsize_get,0 },
6185     { "Amanda::Configc::debug_sendbackup", MAGIC_CLASS _wrap_debug_sendbackup_set, MAGIC_CLASS _wrap_debug_sendbackup_get,0 },
6186 {0,0,0,0}
6187 };
6188 static swig_command_info swig_commands[] = {
6189 {"Amanda::Configc::data_path_from_string", _wrap_data_path_from_string},
6190 {"Amanda::Configc::getconf", _wrap_getconf},
6191 {"Amanda::Configc::getconf_seen", _wrap_getconf_seen},
6192 {"Amanda::Configc::getconf_linenum", _wrap_getconf_linenum},
6193 {"Amanda::Configc::getconf_byname", _wrap_getconf_byname},
6194 {"Amanda::Configc::getconf_list", _wrap_getconf_list},
6195 {"Amanda::Configc::getconf_byname_strs", _wrap_getconf_byname_strs},
6196 {"Amanda::Configc::lookup_tapetype", _wrap_lookup_tapetype},
6197 {"Amanda::Configc::tapetype_getconf", _wrap_tapetype_getconf},
6198 {"Amanda::Configc::tapetype_name", _wrap_tapetype_name},
6199 {"Amanda::Configc::tapetype_seen", _wrap_tapetype_seen},
6200 {"Amanda::Configc::lookup_dumptype", _wrap_lookup_dumptype},
6201 {"Amanda::Configc::dumptype_getconf", _wrap_dumptype_getconf},
6202 {"Amanda::Configc::dumptype_name", _wrap_dumptype_name},
6203 {"Amanda::Configc::dumptype_seen", _wrap_dumptype_seen},
6204 {"Amanda::Configc::lookup_interface", _wrap_lookup_interface},
6205 {"Amanda::Configc::interface_getconf", _wrap_interface_getconf},
6206 {"Amanda::Configc::interface_name", _wrap_interface_name},
6207 {"Amanda::Configc::interface_seen", _wrap_interface_seen},
6208 {"Amanda::Configc::lookup_holdingdisk", _wrap_lookup_holdingdisk},
6209 {"Amanda::Configc::getconf_holdingdisks", _wrap_getconf_holdingdisks},
6210 {"Amanda::Configc::holdingdisk_getconf", _wrap_holdingdisk_getconf},
6211 {"Amanda::Configc::holdingdisk_name", _wrap_holdingdisk_name},
6212 {"Amanda::Configc::holdingdisk_seen", _wrap_holdingdisk_seen},
6213 {"Amanda::Configc::lookup_application", _wrap_lookup_application},
6214 {"Amanda::Configc::application_getconf", _wrap_application_getconf},
6215 {"Amanda::Configc::application_name", _wrap_application_name},
6216 {"Amanda::Configc::application_seen", _wrap_application_seen},
6217 {"Amanda::Configc::lookup_pp_script", _wrap_lookup_pp_script},
6218 {"Amanda::Configc::pp_script_getconf", _wrap_pp_script_getconf},
6219 {"Amanda::Configc::pp_script_name", _wrap_pp_script_name},
6220 {"Amanda::Configc::pp_script_seen", _wrap_pp_script_seen},
6221 {"Amanda::Configc::lookup_device_config", _wrap_lookup_device_config},
6222 {"Amanda::Configc::device_config_getconf", _wrap_device_config_getconf},
6223 {"Amanda::Configc::device_config_name", _wrap_device_config_name},
6224 {"Amanda::Configc::device_config_seen", _wrap_device_config_seen},
6225 {"Amanda::Configc::lookup_changer_config", _wrap_lookup_changer_config},
6226 {"Amanda::Configc::changer_config_getconf", _wrap_changer_config_getconf},
6227 {"Amanda::Configc::changer_config_name", _wrap_changer_config_name},
6228 {"Amanda::Configc::changer_config_seen", _wrap_changer_config_seen},
6229 {"Amanda::Configc::getconf_unit_divisor", _wrap_getconf_unit_divisor},
6230 {"Amanda::Configc::config_init", _wrap_config_init},
6231 {"Amanda::Configc::config_uninit", _wrap_config_uninit},
6232 {"Amanda::Configc::get_config_options", _wrap_get_config_options},
6233 {"Amanda::Configc::get_config_name", _wrap_get_config_name},
6234 {"Amanda::Configc::get_config_dir", _wrap_get_config_dir},
6235 {"Amanda::Configc::get_config_filename", _wrap_get_config_filename},
6236 {"Amanda::Configc::config_print_errors", _wrap_config_print_errors},
6237 {"Amanda::Configc::config_clear_errors", _wrap_config_clear_errors},
6238 {"Amanda::Configc::config_errors", _wrap_config_errors},
6239 {"Amanda::Configc::new_config_overrides", _wrap_new_config_overrides},
6240 {"Amanda::Configc::free_config_overrides", _wrap_free_config_overrides},
6241 {"Amanda::Configc::add_config_override", _wrap_add_config_override},
6242 {"Amanda::Configc::add_config_override_opt", _wrap_add_config_override_opt},
6243 {"Amanda::Configc::set_config_overrides", _wrap_set_config_overrides},
6244 {"Amanda::Configc::dump_configuration", _wrap_dump_configuration},
6245 {"Amanda::Configc::config_dir_relative", _wrap_config_dir_relative},
6246 {"Amanda::Configc::taperalgo2str", _wrap_taperalgo2str},
6247 {"Amanda::Configc::find_multiplier", _wrap_find_multiplier},
6248 {"Amanda::Configc::C_string_to_boolean", _wrap_C_string_to_boolean},
6249 {0,0}
6250 };
6251 /* -----------------------------------------------------------------------------
6252  * Type initialization:
6253  * This problem is tough by the requirement that no dynamic
6254  * memory is used. Also, since swig_type_info structures store pointers to
6255  * swig_cast_info structures and swig_cast_info structures store pointers back
6256  * to swig_type_info structures, we need some lookup code at initialization.
6257  * The idea is that swig generates all the structures that are needed.
6258  * The runtime then collects these partially filled structures.
6259  * The SWIG_InitializeModule function takes these initial arrays out of
6260  * swig_module, and does all the lookup, filling in the swig_module.types
6261  * array with the correct data and linking the correct swig_cast_info
6262  * structures together.
6263  *
6264  * The generated swig_type_info structures are assigned staticly to an initial
6265  * array. We just loop through that array, and handle each type individually.
6266  * First we lookup if this type has been already loaded, and if so, use the
6267  * loaded structure instead of the generated one. Then we have to fill in the
6268  * cast linked list. The cast data is initially stored in something like a
6269  * two-dimensional array. Each row corresponds to a type (there are the same
6270  * number of rows as there are in the swig_type_initial array). Each entry in
6271  * a column is one of the swig_cast_info structures for that type.
6272  * The cast_initial array is actually an array of arrays, because each row has
6273  * a variable number of columns. So to actually build the cast linked list,
6274  * we find the array of casts associated with the type, and loop through it
6275  * adding the casts to the list. The one last trick we need to do is making
6276  * sure the type pointer in the swig_cast_info struct is correct.
6277  *
6278  * First off, we lookup the cast->type name to see if it is already loaded.
6279  * There are three cases to handle:
6280  *  1) If the cast->type has already been loaded AND the type we are adding
6281  *     casting info to has not been loaded (it is in this module), THEN we
6282  *     replace the cast->type pointer with the type pointer that has already
6283  *     been loaded.
6284  *  2) If BOTH types (the one we are adding casting info to, and the
6285  *     cast->type) are loaded, THEN the cast info has already been loaded by
6286  *     the previous module so we just ignore it.
6287  *  3) Finally, if cast->type has not already been loaded, then we add that
6288  *     swig_cast_info to the linked list (because the cast->type) pointer will
6289  *     be correct.
6290  * ----------------------------------------------------------------------------- */
6291
6292 #ifdef __cplusplus
6293 extern "C" {
6294 #if 0
6295 } /* c-mode */
6296 #endif
6297 #endif
6298
6299 #if 0
6300 #define SWIGRUNTIME_DEBUG
6301 #endif
6302
6303
6304 SWIGRUNTIME void
6305 SWIG_InitializeModule(void *clientdata) {
6306   size_t i;
6307   swig_module_info *module_head, *iter;
6308   int found, init;
6309
6310   clientdata = clientdata;
6311
6312   /* check to see if the circular list has been setup, if not, set it up */
6313   if (swig_module.next==0) {
6314     /* Initialize the swig_module */
6315     swig_module.type_initial = swig_type_initial;
6316     swig_module.cast_initial = swig_cast_initial;
6317     swig_module.next = &swig_module;
6318     init = 1;
6319   } else {
6320     init = 0;
6321   }
6322
6323   /* Try and load any already created modules */
6324   module_head = SWIG_GetModule(clientdata);
6325   if (!module_head) {
6326     /* This is the first module loaded for this interpreter */
6327     /* so set the swig module into the interpreter */
6328     SWIG_SetModule(clientdata, &swig_module);
6329     module_head = &swig_module;
6330   } else {
6331     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
6332     found=0;
6333     iter=module_head;
6334     do {
6335       if (iter==&swig_module) {
6336         found=1;
6337         break;
6338       }
6339       iter=iter->next;
6340     } while (iter!= module_head);
6341
6342     /* if the is found in the list, then all is done and we may leave */
6343     if (found) return;
6344     /* otherwise we must add out module into the list */
6345     swig_module.next = module_head->next;
6346     module_head->next = &swig_module;
6347   }
6348
6349   /* When multiple interpeters are used, a module could have already been initialized in
6350        a different interpreter, but not yet have a pointer in this interpreter.
6351        In this case, we do not want to continue adding types... everything should be
6352        set up already */
6353   if (init == 0) return;
6354
6355   /* Now work on filling in swig_module.types */
6356 #ifdef SWIGRUNTIME_DEBUG
6357   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
6358 #endif
6359   for (i = 0; i < swig_module.size; ++i) {
6360     swig_type_info *type = 0;
6361     swig_type_info *ret;
6362     swig_cast_info *cast;
6363
6364 #ifdef SWIGRUNTIME_DEBUG
6365     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6366 #endif
6367
6368     /* if there is another module already loaded */
6369     if (swig_module.next != &swig_module) {
6370       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
6371     }
6372     if (type) {
6373       /* Overwrite clientdata field */
6374 #ifdef SWIGRUNTIME_DEBUG
6375       printf("SWIG_InitializeModule: found type %s\n", type->name);
6376 #endif
6377       if (swig_module.type_initial[i]->clientdata) {
6378         type->clientdata = swig_module.type_initial[i]->clientdata;
6379 #ifdef SWIGRUNTIME_DEBUG
6380         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
6381 #endif
6382       }
6383     } else {
6384       type = swig_module.type_initial[i];
6385     }
6386
6387     /* Insert casting types */
6388     cast = swig_module.cast_initial[i];
6389     while (cast->type) {
6390       /* Don't need to add information already in the list */
6391       ret = 0;
6392 #ifdef SWIGRUNTIME_DEBUG
6393       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
6394 #endif
6395       if (swig_module.next != &swig_module) {
6396         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
6397 #ifdef SWIGRUNTIME_DEBUG
6398         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
6399 #endif
6400       }
6401       if (ret) {
6402         if (type == swig_module.type_initial[i]) {
6403 #ifdef SWIGRUNTIME_DEBUG
6404           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
6405 #endif
6406           cast->type = ret;
6407           ret = 0;
6408         } else {
6409           /* Check for casting already in the list */
6410           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
6411 #ifdef SWIGRUNTIME_DEBUG
6412           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
6413 #endif
6414           if (!ocast) ret = 0;
6415         }
6416       }
6417
6418       if (!ret) {
6419 #ifdef SWIGRUNTIME_DEBUG
6420         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
6421 #endif
6422         if (type->cast) {
6423           type->cast->prev = cast;
6424           cast->next = type->cast;
6425         }
6426         type->cast = cast;
6427       }
6428       cast++;
6429     }
6430     /* Set entry in modules->types array equal to the type */
6431     swig_module.types[i] = type;
6432   }
6433   swig_module.types[i] = 0;
6434
6435 #ifdef SWIGRUNTIME_DEBUG
6436   printf("**** SWIG_InitializeModule: Cast List ******\n");
6437   for (i = 0; i < swig_module.size; ++i) {
6438     int j = 0;
6439     swig_cast_info *cast = swig_module.cast_initial[i];
6440     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6441     while (cast->type) {
6442       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
6443       cast++;
6444       ++j;
6445     }
6446     printf("---- Total casts: %d\n",j);
6447   }
6448   printf("**** SWIG_InitializeModule: Cast List ******\n");
6449 #endif
6450 }
6451
6452 /* This function will propagate the clientdata field of type to
6453 * any new swig_type_info structures that have been added into the list
6454 * of equivalent types.  It is like calling
6455 * SWIG_TypeClientData(type, clientdata) a second time.
6456 */
6457 SWIGRUNTIME void
6458 SWIG_PropagateClientData(void) {
6459   size_t i;
6460   swig_cast_info *equiv;
6461   static int init_run = 0;
6462
6463   if (init_run) return;
6464   init_run = 1;
6465
6466   for (i = 0; i < swig_module.size; i++) {
6467     if (swig_module.types[i]->clientdata) {
6468       equiv = swig_module.types[i]->cast;
6469       while (equiv) {
6470         if (!equiv->converter) {
6471           if (equiv->type && !equiv->type->clientdata)
6472           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
6473         }
6474         equiv = equiv->next;
6475       }
6476     }
6477   }
6478 }
6479
6480 #ifdef __cplusplus
6481 #if 0
6482 {
6483   /* c-mode */
6484 #endif
6485 }
6486 #endif
6487
6488
6489
6490 #ifdef __cplusplus
6491 extern "C"
6492 #endif
6493
6494 XS(SWIG_init) {
6495   dXSARGS;
6496   int i;
6497
6498   SWIG_InitializeModule(0);
6499
6500   /* Install commands */
6501   for (i = 0; swig_commands[i].name; i++) {
6502     newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
6503   }
6504
6505   /* Install variables */
6506   for (i = 0; swig_variables[i].name; i++) {
6507     SV *sv;
6508     sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
6509     if (swig_variables[i].type) {
6510       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
6511     } else {
6512       sv_setiv(sv,(IV) 0);
6513     }
6514     swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
6515   }
6516
6517   /* Install constant */
6518   for (i = 0; swig_constants[i].type; i++) {
6519     SV *sv;
6520     sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
6521     switch(swig_constants[i].type) {
6522     case SWIG_INT:
6523       sv_setiv(sv, (IV) swig_constants[i].lvalue);
6524       break;
6525     case SWIG_FLOAT:
6526       sv_setnv(sv, (double) swig_constants[i].dvalue);
6527       break;
6528     case SWIG_STRING:
6529       sv_setpv(sv, (char *) swig_constants[i].pvalue);
6530       break;
6531     case SWIG_POINTER:
6532       SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
6533       break;
6534     case SWIG_BINARY:
6535       SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
6536       break;
6537     default:
6538       break;
6539     }
6540     SvREADONLY_on(sv);
6541   }
6542
6543   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6544     SV *sv = get_sv((char*) SWIG_prefix "CNF_ORG", TRUE | 0x2 | GV_ADDMULTI);
6545     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_ORG)));
6546     SvREADONLY_on(sv);
6547   } while(0) /*@SWIG@*/;
6548   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6549     SV *sv = get_sv((char*) SWIG_prefix "CNF_CONF", TRUE | 0x2 | GV_ADDMULTI);
6550     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CONF)));
6551     SvREADONLY_on(sv);
6552   } while(0) /*@SWIG@*/;
6553   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6554     SV *sv = get_sv((char*) SWIG_prefix "CNF_INDEX_SERVER", TRUE | 0x2 | GV_ADDMULTI);
6555     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_INDEX_SERVER)));
6556     SvREADONLY_on(sv);
6557   } while(0) /*@SWIG@*/;
6558   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6559     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPE_SERVER", TRUE | 0x2 | GV_ADDMULTI);
6560     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPE_SERVER)));
6561     SvREADONLY_on(sv);
6562   } while(0) /*@SWIG@*/;
6563   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6564     SV *sv = get_sv((char*) SWIG_prefix "CNF_AUTH", TRUE | 0x2 | GV_ADDMULTI);
6565     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AUTH)));
6566     SvREADONLY_on(sv);
6567   } while(0) /*@SWIG@*/;
6568   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6569     SV *sv = get_sv((char*) SWIG_prefix "CNF_SSH_KEYS", TRUE | 0x2 | GV_ADDMULTI);
6570     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_SSH_KEYS)));
6571     SvREADONLY_on(sv);
6572   } while(0) /*@SWIG@*/;
6573   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6574     SV *sv = get_sv((char*) SWIG_prefix "CNF_AMANDAD_PATH", TRUE | 0x2 | GV_ADDMULTI);
6575     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AMANDAD_PATH)));
6576     SvREADONLY_on(sv);
6577   } while(0) /*@SWIG@*/;
6578   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6579     SV *sv = get_sv((char*) SWIG_prefix "CNF_CLIENT_USERNAME", TRUE | 0x2 | GV_ADDMULTI);
6580     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CLIENT_USERNAME)));
6581     SvREADONLY_on(sv);
6582   } while(0) /*@SWIG@*/;
6583   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6584     SV *sv = get_sv((char*) SWIG_prefix "CNF_CLIENT_PORT", TRUE | 0x2 | GV_ADDMULTI);
6585     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CLIENT_PORT)));
6586     SvREADONLY_on(sv);
6587   } while(0) /*@SWIG@*/;
6588   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6589     SV *sv = get_sv((char*) SWIG_prefix "CNF_GNUTAR_LIST_DIR", TRUE | 0x2 | GV_ADDMULTI);
6590     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_GNUTAR_LIST_DIR)));
6591     SvREADONLY_on(sv);
6592   } while(0) /*@SWIG@*/;
6593   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6594     SV *sv = get_sv((char*) SWIG_prefix "CNF_AMANDATES", TRUE | 0x2 | GV_ADDMULTI);
6595     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AMANDATES)));
6596     SvREADONLY_on(sv);
6597   } while(0) /*@SWIG@*/;
6598   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6599     SV *sv = get_sv((char*) SWIG_prefix "CNF_MAILER", TRUE | 0x2 | GV_ADDMULTI);
6600     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_MAILER)));
6601     SvREADONLY_on(sv);
6602   } while(0) /*@SWIG@*/;
6603   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6604     SV *sv = get_sv((char*) SWIG_prefix "CNF_MAILTO", TRUE | 0x2 | GV_ADDMULTI);
6605     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_MAILTO)));
6606     SvREADONLY_on(sv);
6607   } while(0) /*@SWIG@*/;
6608   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6609     SV *sv = get_sv((char*) SWIG_prefix "CNF_DUMPUSER", TRUE | 0x2 | GV_ADDMULTI);
6610     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DUMPUSER)));
6611     SvREADONLY_on(sv);
6612   } while(0) /*@SWIG@*/;
6613   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6614     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPEDEV", TRUE | 0x2 | GV_ADDMULTI);
6615     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPEDEV)));
6616     SvREADONLY_on(sv);
6617   } while(0) /*@SWIG@*/;
6618   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6619     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEVICE_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
6620     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEVICE_PROPERTY)));
6621     SvREADONLY_on(sv);
6622   } while(0) /*@SWIG@*/;
6623   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6624     SV *sv = get_sv((char*) SWIG_prefix "CNF_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
6625     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_PROPERTY)));
6626     SvREADONLY_on(sv);
6627   } while(0) /*@SWIG@*/;
6628   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6629     SV *sv = get_sv((char*) SWIG_prefix "CNF_CHANGERDEV", TRUE | 0x2 | GV_ADDMULTI);
6630     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CHANGERDEV)));
6631     SvREADONLY_on(sv);
6632   } while(0) /*@SWIG@*/;
6633   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6634     SV *sv = get_sv((char*) SWIG_prefix "CNF_CHANGERFILE", TRUE | 0x2 | GV_ADDMULTI);
6635     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CHANGERFILE)));
6636     SvREADONLY_on(sv);
6637   } while(0) /*@SWIG@*/;
6638   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6639     SV *sv = get_sv((char*) SWIG_prefix "CNF_LABELSTR", TRUE | 0x2 | GV_ADDMULTI);
6640     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_LABELSTR)));
6641     SvREADONLY_on(sv);
6642   } while(0) /*@SWIG@*/;
6643   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6644     SV *sv = get_sv((char*) SWIG_prefix "CNF_AUTOLABEL", TRUE | 0x2 | GV_ADDMULTI);
6645     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AUTOLABEL)));
6646     SvREADONLY_on(sv);
6647   } while(0) /*@SWIG@*/;
6648   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6649     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPELIST", TRUE | 0x2 | GV_ADDMULTI);
6650     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPELIST)));
6651     SvREADONLY_on(sv);
6652   } while(0) /*@SWIG@*/;
6653   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6654     SV *sv = get_sv((char*) SWIG_prefix "CNF_DISKFILE", TRUE | 0x2 | GV_ADDMULTI);
6655     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DISKFILE)));
6656     SvREADONLY_on(sv);
6657   } while(0) /*@SWIG@*/;
6658   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6659     SV *sv = get_sv((char*) SWIG_prefix "CNF_INFOFILE", TRUE | 0x2 | GV_ADDMULTI);
6660     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_INFOFILE)));
6661     SvREADONLY_on(sv);
6662   } while(0) /*@SWIG@*/;
6663   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6664     SV *sv = get_sv((char*) SWIG_prefix "CNF_LOGDIR", TRUE | 0x2 | GV_ADDMULTI);
6665     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_LOGDIR)));
6666     SvREADONLY_on(sv);
6667   } while(0) /*@SWIG@*/;
6668   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6669     SV *sv = get_sv((char*) SWIG_prefix "CNF_INDEXDIR", TRUE | 0x2 | GV_ADDMULTI);
6670     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_INDEXDIR)));
6671     SvREADONLY_on(sv);
6672   } while(0) /*@SWIG@*/;
6673   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6674     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPETYPE", TRUE | 0x2 | GV_ADDMULTI);
6675     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPETYPE)));
6676     SvREADONLY_on(sv);
6677   } while(0) /*@SWIG@*/;
6678   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6679     SV *sv = get_sv((char*) SWIG_prefix "CNF_DUMPCYCLE", TRUE | 0x2 | GV_ADDMULTI);
6680     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DUMPCYCLE)));
6681     SvREADONLY_on(sv);
6682   } while(0) /*@SWIG@*/;
6683   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6684     SV *sv = get_sv((char*) SWIG_prefix "CNF_RUNSPERCYCLE", TRUE | 0x2 | GV_ADDMULTI);
6685     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_RUNSPERCYCLE)));
6686     SvREADONLY_on(sv);
6687   } while(0) /*@SWIG@*/;
6688   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6689     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPECYCLE", TRUE | 0x2 | GV_ADDMULTI);
6690     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPECYCLE)));
6691     SvREADONLY_on(sv);
6692   } while(0) /*@SWIG@*/;
6693   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6694     SV *sv = get_sv((char*) SWIG_prefix "CNF_NETUSAGE", TRUE | 0x2 | GV_ADDMULTI);
6695     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_NETUSAGE)));
6696     SvREADONLY_on(sv);
6697   } while(0) /*@SWIG@*/;
6698   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6699     SV *sv = get_sv((char*) SWIG_prefix "CNF_INPARALLEL", TRUE | 0x2 | GV_ADDMULTI);
6700     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_INPARALLEL)));
6701     SvREADONLY_on(sv);
6702   } while(0) /*@SWIG@*/;
6703   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6704     SV *sv = get_sv((char*) SWIG_prefix "CNF_DUMPORDER", TRUE | 0x2 | GV_ADDMULTI);
6705     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DUMPORDER)));
6706     SvREADONLY_on(sv);
6707   } while(0) /*@SWIG@*/;
6708   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6709     SV *sv = get_sv((char*) SWIG_prefix "CNF_BUMPPERCENT", TRUE | 0x2 | GV_ADDMULTI);
6710     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_BUMPPERCENT)));
6711     SvREADONLY_on(sv);
6712   } while(0) /*@SWIG@*/;
6713   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6714     SV *sv = get_sv((char*) SWIG_prefix "CNF_BUMPSIZE", TRUE | 0x2 | GV_ADDMULTI);
6715     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_BUMPSIZE)));
6716     SvREADONLY_on(sv);
6717   } while(0) /*@SWIG@*/;
6718   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6719     SV *sv = get_sv((char*) SWIG_prefix "CNF_BUMPMULT", TRUE | 0x2 | GV_ADDMULTI);
6720     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_BUMPMULT)));
6721     SvREADONLY_on(sv);
6722   } while(0) /*@SWIG@*/;
6723   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6724     SV *sv = get_sv((char*) SWIG_prefix "CNF_BUMPDAYS", TRUE | 0x2 | GV_ADDMULTI);
6725     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_BUMPDAYS)));
6726     SvREADONLY_on(sv);
6727   } while(0) /*@SWIG@*/;
6728   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6729     SV *sv = get_sv((char*) SWIG_prefix "CNF_TPCHANGER", TRUE | 0x2 | GV_ADDMULTI);
6730     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TPCHANGER)));
6731     SvREADONLY_on(sv);
6732   } while(0) /*@SWIG@*/;
6733   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6734     SV *sv = get_sv((char*) SWIG_prefix "CNF_RUNTAPES", TRUE | 0x2 | GV_ADDMULTI);
6735     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_RUNTAPES)));
6736     SvREADONLY_on(sv);
6737   } while(0) /*@SWIG@*/;
6738   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6739     SV *sv = get_sv((char*) SWIG_prefix "CNF_MAXDUMPS", TRUE | 0x2 | GV_ADDMULTI);
6740     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_MAXDUMPS)));
6741     SvREADONLY_on(sv);
6742   } while(0) /*@SWIG@*/;
6743   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6744     SV *sv = get_sv((char*) SWIG_prefix "CNF_ETIMEOUT", TRUE | 0x2 | GV_ADDMULTI);
6745     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_ETIMEOUT)));
6746     SvREADONLY_on(sv);
6747   } while(0) /*@SWIG@*/;
6748   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6749     SV *sv = get_sv((char*) SWIG_prefix "CNF_DTIMEOUT", TRUE | 0x2 | GV_ADDMULTI);
6750     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DTIMEOUT)));
6751     SvREADONLY_on(sv);
6752   } while(0) /*@SWIG@*/;
6753   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6754     SV *sv = get_sv((char*) SWIG_prefix "CNF_CTIMEOUT", TRUE | 0x2 | GV_ADDMULTI);
6755     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CTIMEOUT)));
6756     SvREADONLY_on(sv);
6757   } while(0) /*@SWIG@*/;
6758   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6759     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPEBUFS", TRUE | 0x2 | GV_ADDMULTI);
6760     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPEBUFS)));
6761     SvREADONLY_on(sv);
6762   } while(0) /*@SWIG@*/;
6763   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6764     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEVICE_OUTPUT_BUFFER_SIZE", TRUE | 0x2 | GV_ADDMULTI);
6765     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEVICE_OUTPUT_BUFFER_SIZE)));
6766     SvREADONLY_on(sv);
6767   } while(0) /*@SWIG@*/;
6768   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6769     SV *sv = get_sv((char*) SWIG_prefix "CNF_PRINTER", TRUE | 0x2 | GV_ADDMULTI);
6770     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_PRINTER)));
6771     SvREADONLY_on(sv);
6772   } while(0) /*@SWIG@*/;
6773   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6774     SV *sv = get_sv((char*) SWIG_prefix "CNF_AUTOFLUSH", TRUE | 0x2 | GV_ADDMULTI);
6775     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AUTOFLUSH)));
6776     SvREADONLY_on(sv);
6777   } while(0) /*@SWIG@*/;
6778   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6779     SV *sv = get_sv((char*) SWIG_prefix "CNF_RESERVE", TRUE | 0x2 | GV_ADDMULTI);
6780     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_RESERVE)));
6781     SvREADONLY_on(sv);
6782   } while(0) /*@SWIG@*/;
6783   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6784     SV *sv = get_sv((char*) SWIG_prefix "CNF_MAXDUMPSIZE", TRUE | 0x2 | GV_ADDMULTI);
6785     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_MAXDUMPSIZE)));
6786     SvREADONLY_on(sv);
6787   } while(0) /*@SWIG@*/;
6788   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6789     SV *sv = get_sv((char*) SWIG_prefix "CNF_COLUMNSPEC", TRUE | 0x2 | GV_ADDMULTI);
6790     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_COLUMNSPEC)));
6791     SvREADONLY_on(sv);
6792   } while(0) /*@SWIG@*/;
6793   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6794     SV *sv = get_sv((char*) SWIG_prefix "CNF_AMRECOVER_DO_FSF", TRUE | 0x2 | GV_ADDMULTI);
6795     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AMRECOVER_DO_FSF)));
6796     SvREADONLY_on(sv);
6797   } while(0) /*@SWIG@*/;
6798   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6799     SV *sv = get_sv((char*) SWIG_prefix "CNF_AMRECOVER_CHECK_LABEL", TRUE | 0x2 | GV_ADDMULTI);
6800     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AMRECOVER_CHECK_LABEL)));
6801     SvREADONLY_on(sv);
6802   } while(0) /*@SWIG@*/;
6803   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6804     SV *sv = get_sv((char*) SWIG_prefix "CNF_AMRECOVER_CHANGER", TRUE | 0x2 | GV_ADDMULTI);
6805     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AMRECOVER_CHANGER)));
6806     SvREADONLY_on(sv);
6807   } while(0) /*@SWIG@*/;
6808   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6809     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPERALGO", TRUE | 0x2 | GV_ADDMULTI);
6810     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPERALGO)));
6811     SvREADONLY_on(sv);
6812   } while(0) /*@SWIG@*/;
6813   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6814     SV *sv = get_sv((char*) SWIG_prefix "CNF_FLUSH_THRESHOLD_DUMPED", TRUE | 0x2 | GV_ADDMULTI);
6815     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_FLUSH_THRESHOLD_DUMPED)));
6816     SvREADONLY_on(sv);
6817   } while(0) /*@SWIG@*/;
6818   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6819     SV *sv = get_sv((char*) SWIG_prefix "CNF_FLUSH_THRESHOLD_SCHEDULED", TRUE | 0x2 | GV_ADDMULTI);
6820     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_FLUSH_THRESHOLD_SCHEDULED)));
6821     SvREADONLY_on(sv);
6822   } while(0) /*@SWIG@*/;
6823   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6824     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPERFLUSH", TRUE | 0x2 | GV_ADDMULTI);
6825     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPERFLUSH)));
6826     SvREADONLY_on(sv);
6827   } while(0) /*@SWIG@*/;
6828   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6829     SV *sv = get_sv((char*) SWIG_prefix "CNF_DISPLAYUNIT", TRUE | 0x2 | GV_ADDMULTI);
6830     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DISPLAYUNIT)));
6831     SvREADONLY_on(sv);
6832   } while(0) /*@SWIG@*/;
6833   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6834     SV *sv = get_sv((char*) SWIG_prefix "CNF_KRB5KEYTAB", TRUE | 0x2 | GV_ADDMULTI);
6835     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_KRB5KEYTAB)));
6836     SvREADONLY_on(sv);
6837   } while(0) /*@SWIG@*/;
6838   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6839     SV *sv = get_sv((char*) SWIG_prefix "CNF_KRB5PRINCIPAL", TRUE | 0x2 | GV_ADDMULTI);
6840     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_KRB5PRINCIPAL)));
6841     SvREADONLY_on(sv);
6842   } while(0) /*@SWIG@*/;
6843   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6844     SV *sv = get_sv((char*) SWIG_prefix "CNF_LABEL_NEW_TAPES", TRUE | 0x2 | GV_ADDMULTI);
6845     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_LABEL_NEW_TAPES)));
6846     SvREADONLY_on(sv);
6847   } while(0) /*@SWIG@*/;
6848   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6849     SV *sv = get_sv((char*) SWIG_prefix "CNF_USETIMESTAMPS", TRUE | 0x2 | GV_ADDMULTI);
6850     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_USETIMESTAMPS)));
6851     SvREADONLY_on(sv);
6852   } while(0) /*@SWIG@*/;
6853   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6854     SV *sv = get_sv((char*) SWIG_prefix "CNF_REP_TRIES", TRUE | 0x2 | GV_ADDMULTI);
6855     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_REP_TRIES)));
6856     SvREADONLY_on(sv);
6857   } while(0) /*@SWIG@*/;
6858   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6859     SV *sv = get_sv((char*) SWIG_prefix "CNF_CONNECT_TRIES", TRUE | 0x2 | GV_ADDMULTI);
6860     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CONNECT_TRIES)));
6861     SvREADONLY_on(sv);
6862   } while(0) /*@SWIG@*/;
6863   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6864     SV *sv = get_sv((char*) SWIG_prefix "CNF_REQ_TRIES", TRUE | 0x2 | GV_ADDMULTI);
6865     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_REQ_TRIES)));
6866     SvREADONLY_on(sv);
6867   } while(0) /*@SWIG@*/;
6868   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6869     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_AMANDAD", TRUE | 0x2 | GV_ADDMULTI);
6870     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_AMANDAD)));
6871     SvREADONLY_on(sv);
6872   } while(0) /*@SWIG@*/;
6873   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6874     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_RECOVERY", TRUE | 0x2 | GV_ADDMULTI);
6875     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_RECOVERY)));
6876     SvREADONLY_on(sv);
6877   } while(0) /*@SWIG@*/;
6878   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6879     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_AMIDXTAPED", TRUE | 0x2 | GV_ADDMULTI);
6880     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_AMIDXTAPED)));
6881     SvREADONLY_on(sv);
6882   } while(0) /*@SWIG@*/;
6883   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6884     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_AMINDEXD", TRUE | 0x2 | GV_ADDMULTI);
6885     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_AMINDEXD)));
6886     SvREADONLY_on(sv);
6887   } while(0) /*@SWIG@*/;
6888   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6889     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_AMRECOVER", TRUE | 0x2 | GV_ADDMULTI);
6890     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_AMRECOVER)));
6891     SvREADONLY_on(sv);
6892   } while(0) /*@SWIG@*/;
6893   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6894     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_AUTH", TRUE | 0x2 | GV_ADDMULTI);
6895     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_AUTH)));
6896     SvREADONLY_on(sv);
6897   } while(0) /*@SWIG@*/;
6898   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6899     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_EVENT", TRUE | 0x2 | GV_ADDMULTI);
6900     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_EVENT)));
6901     SvREADONLY_on(sv);
6902   } while(0) /*@SWIG@*/;
6903   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6904     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_HOLDING", TRUE | 0x2 | GV_ADDMULTI);
6905     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_HOLDING)));
6906     SvREADONLY_on(sv);
6907   } while(0) /*@SWIG@*/;
6908   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6909     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_PROTOCOL", TRUE | 0x2 | GV_ADDMULTI);
6910     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_PROTOCOL)));
6911     SvREADONLY_on(sv);
6912   } while(0) /*@SWIG@*/;
6913   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6914     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_PLANNER", TRUE | 0x2 | GV_ADDMULTI);
6915     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_PLANNER)));
6916     SvREADONLY_on(sv);
6917   } while(0) /*@SWIG@*/;
6918   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6919     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_DRIVER", TRUE | 0x2 | GV_ADDMULTI);
6920     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_DRIVER)));
6921     SvREADONLY_on(sv);
6922   } while(0) /*@SWIG@*/;
6923   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6924     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_DUMPER", TRUE | 0x2 | GV_ADDMULTI);
6925     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_DUMPER)));
6926     SvREADONLY_on(sv);
6927   } while(0) /*@SWIG@*/;
6928   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6929     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_CHUNKER", TRUE | 0x2 | GV_ADDMULTI);
6930     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_CHUNKER)));
6931     SvREADONLY_on(sv);
6932   } while(0) /*@SWIG@*/;
6933   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6934     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_TAPER", TRUE | 0x2 | GV_ADDMULTI);
6935     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_TAPER)));
6936     SvREADONLY_on(sv);
6937   } while(0) /*@SWIG@*/;
6938   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6939     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_SELFCHECK", TRUE | 0x2 | GV_ADDMULTI);
6940     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_SELFCHECK)));
6941     SvREADONLY_on(sv);
6942   } while(0) /*@SWIG@*/;
6943   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6944     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_SENDSIZE", TRUE | 0x2 | GV_ADDMULTI);
6945     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_SENDSIZE)));
6946     SvREADONLY_on(sv);
6947   } while(0) /*@SWIG@*/;
6948   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6949     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_SENDBACKUP", TRUE | 0x2 | GV_ADDMULTI);
6950     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_SENDBACKUP)));
6951     SvREADONLY_on(sv);
6952   } while(0) /*@SWIG@*/;
6953   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6954     SV *sv = get_sv((char*) SWIG_prefix "CNF_RESERVED_UDP_PORT", TRUE | 0x2 | GV_ADDMULTI);
6955     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_RESERVED_UDP_PORT)));
6956     SvREADONLY_on(sv);
6957   } while(0) /*@SWIG@*/;
6958   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6959     SV *sv = get_sv((char*) SWIG_prefix "CNF_RESERVED_TCP_PORT", TRUE | 0x2 | GV_ADDMULTI);
6960     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_RESERVED_TCP_PORT)));
6961     SvREADONLY_on(sv);
6962   } while(0) /*@SWIG@*/;
6963   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6964     SV *sv = get_sv((char*) SWIG_prefix "CNF_UNRESERVED_TCP_PORT", TRUE | 0x2 | GV_ADDMULTI);
6965     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_UNRESERVED_TCP_PORT)));
6966     SvREADONLY_on(sv);
6967   } while(0) /*@SWIG@*/;
6968   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6969     SV *sv = get_sv((char*) SWIG_prefix "CNF_HOLDINGDISK", TRUE | 0x2 | GV_ADDMULTI);
6970     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_HOLDINGDISK)));
6971     SvREADONLY_on(sv);
6972   } while(0) /*@SWIG@*/;
6973   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6974     SV *sv = get_sv((char*) SWIG_prefix "CNF_SEND_AMREPORT_ON", TRUE | 0x2 | GV_ADDMULTI);
6975     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_SEND_AMREPORT_ON)));
6976     SvREADONLY_on(sv);
6977   } while(0) /*@SWIG@*/;
6978   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6979     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
6980     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_COMMENT)));
6981     SvREADONLY_on(sv);
6982   } while(0) /*@SWIG@*/;
6983   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6984     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_LBL_TEMPL", TRUE | 0x2 | GV_ADDMULTI);
6985     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_LBL_TEMPL)));
6986     SvREADONLY_on(sv);
6987   } while(0) /*@SWIG@*/;
6988   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6989     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_BLOCKSIZE", TRUE | 0x2 | GV_ADDMULTI);
6990     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_BLOCKSIZE)));
6991     SvREADONLY_on(sv);
6992   } while(0) /*@SWIG@*/;
6993   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6994     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_READBLOCKSIZE", TRUE | 0x2 | GV_ADDMULTI);
6995     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_READBLOCKSIZE)));
6996     SvREADONLY_on(sv);
6997   } while(0) /*@SWIG@*/;
6998   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6999     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_LENGTH", TRUE | 0x2 | GV_ADDMULTI);
7000     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_LENGTH)));
7001     SvREADONLY_on(sv);
7002   } while(0) /*@SWIG@*/;
7003   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7004     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_FILEMARK", TRUE | 0x2 | GV_ADDMULTI);
7005     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_FILEMARK)));
7006     SvREADONLY_on(sv);
7007   } while(0) /*@SWIG@*/;
7008   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7009     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_SPEED", TRUE | 0x2 | GV_ADDMULTI);
7010     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_SPEED)));
7011     SvREADONLY_on(sv);
7012   } while(0) /*@SWIG@*/;
7013   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7014     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_FILE_PAD", TRUE | 0x2 | GV_ADDMULTI);
7015     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_FILE_PAD)));
7016     SvREADONLY_on(sv);
7017   } while(0) /*@SWIG@*/;
7018   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7019     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
7020     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_COMMENT)));
7021     SvREADONLY_on(sv);
7022   } while(0) /*@SWIG@*/;
7023   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7024     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_PROGRAM", TRUE | 0x2 | GV_ADDMULTI);
7025     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_PROGRAM)));
7026     SvREADONLY_on(sv);
7027   } while(0) /*@SWIG@*/;
7028   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7029     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SRVCOMPPROG", TRUE | 0x2 | GV_ADDMULTI);
7030     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SRVCOMPPROG)));
7031     SvREADONLY_on(sv);
7032   } while(0) /*@SWIG@*/;
7033   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7034     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_CLNTCOMPPROG", TRUE | 0x2 | GV_ADDMULTI);
7035     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_CLNTCOMPPROG)));
7036     SvREADONLY_on(sv);
7037   } while(0) /*@SWIG@*/;
7038   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7039     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SRV_ENCRYPT", TRUE | 0x2 | GV_ADDMULTI);
7040     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SRV_ENCRYPT)));
7041     SvREADONLY_on(sv);
7042   } while(0) /*@SWIG@*/;
7043   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7044     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_CLNT_ENCRYPT", TRUE | 0x2 | GV_ADDMULTI);
7045     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_CLNT_ENCRYPT)));
7046     SvREADONLY_on(sv);
7047   } while(0) /*@SWIG@*/;
7048   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7049     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_AMANDAD_PATH", TRUE | 0x2 | GV_ADDMULTI);
7050     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_AMANDAD_PATH)));
7051     SvREADONLY_on(sv);
7052   } while(0) /*@SWIG@*/;
7053   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7054     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_CLIENT_USERNAME", TRUE | 0x2 | GV_ADDMULTI);
7055     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_CLIENT_USERNAME)));
7056     SvREADONLY_on(sv);
7057   } while(0) /*@SWIG@*/;
7058   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7059     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_CLIENT_PORT", TRUE | 0x2 | GV_ADDMULTI);
7060     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_CLIENT_PORT)));
7061     SvREADONLY_on(sv);
7062   } while(0) /*@SWIG@*/;
7063   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7064     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SSH_KEYS", TRUE | 0x2 | GV_ADDMULTI);
7065     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SSH_KEYS)));
7066     SvREADONLY_on(sv);
7067   } while(0) /*@SWIG@*/;
7068   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7069     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_AUTH", TRUE | 0x2 | GV_ADDMULTI);
7070     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_AUTH)));
7071     SvREADONLY_on(sv);
7072   } while(0) /*@SWIG@*/;
7073   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7074     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_EXCLUDE", TRUE | 0x2 | GV_ADDMULTI);
7075     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_EXCLUDE)));
7076     SvREADONLY_on(sv);
7077   } while(0) /*@SWIG@*/;
7078   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7079     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_INCLUDE", TRUE | 0x2 | GV_ADDMULTI);
7080     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_INCLUDE)));
7081     SvREADONLY_on(sv);
7082   } while(0) /*@SWIG@*/;
7083   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7084     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_PRIORITY", TRUE | 0x2 | GV_ADDMULTI);
7085     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_PRIORITY)));
7086     SvREADONLY_on(sv);
7087   } while(0) /*@SWIG@*/;
7088   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7089     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_DUMPCYCLE", TRUE | 0x2 | GV_ADDMULTI);
7090     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_DUMPCYCLE)));
7091     SvREADONLY_on(sv);
7092   } while(0) /*@SWIG@*/;
7093   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7094     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_MAXDUMPS", TRUE | 0x2 | GV_ADDMULTI);
7095     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_MAXDUMPS)));
7096     SvREADONLY_on(sv);
7097   } while(0) /*@SWIG@*/;
7098   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7099     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_MAXPROMOTEDAY", TRUE | 0x2 | GV_ADDMULTI);
7100     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_MAXPROMOTEDAY)));
7101     SvREADONLY_on(sv);
7102   } while(0) /*@SWIG@*/;
7103   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7104     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_BUMPPERCENT", TRUE | 0x2 | GV_ADDMULTI);
7105     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_BUMPPERCENT)));
7106     SvREADONLY_on(sv);
7107   } while(0) /*@SWIG@*/;
7108   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7109     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_BUMPSIZE", TRUE | 0x2 | GV_ADDMULTI);
7110     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_BUMPSIZE)));
7111     SvREADONLY_on(sv);
7112   } while(0) /*@SWIG@*/;
7113   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7114     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_BUMPDAYS", TRUE | 0x2 | GV_ADDMULTI);
7115     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_BUMPDAYS)));
7116     SvREADONLY_on(sv);
7117   } while(0) /*@SWIG@*/;
7118   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7119     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_BUMPMULT", TRUE | 0x2 | GV_ADDMULTI);
7120     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_BUMPMULT)));
7121     SvREADONLY_on(sv);
7122   } while(0) /*@SWIG@*/;
7123   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7124     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_STARTTIME", TRUE | 0x2 | GV_ADDMULTI);
7125     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_STARTTIME)));
7126     SvREADONLY_on(sv);
7127   } while(0) /*@SWIG@*/;
7128   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7129     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_STRATEGY", TRUE | 0x2 | GV_ADDMULTI);
7130     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_STRATEGY)));
7131     SvREADONLY_on(sv);
7132   } while(0) /*@SWIG@*/;
7133   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7134     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_ESTIMATELIST", TRUE | 0x2 | GV_ADDMULTI);
7135     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_ESTIMATELIST)));
7136     SvREADONLY_on(sv);
7137   } while(0) /*@SWIG@*/;
7138   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7139     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_COMPRESS", TRUE | 0x2 | GV_ADDMULTI);
7140     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_COMPRESS)));
7141     SvREADONLY_on(sv);
7142   } while(0) /*@SWIG@*/;
7143   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7144     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_ENCRYPT", TRUE | 0x2 | GV_ADDMULTI);
7145     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_ENCRYPT)));
7146     SvREADONLY_on(sv);
7147   } while(0) /*@SWIG@*/;
7148   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7149     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SRV_DECRYPT_OPT", TRUE | 0x2 | GV_ADDMULTI);
7150     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SRV_DECRYPT_OPT)));
7151     SvREADONLY_on(sv);
7152   } while(0) /*@SWIG@*/;
7153   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7154     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_CLNT_DECRYPT_OPT", TRUE | 0x2 | GV_ADDMULTI);
7155     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_CLNT_DECRYPT_OPT)));
7156     SvREADONLY_on(sv);
7157   } while(0) /*@SWIG@*/;
7158   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7159     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_COMPRATE", TRUE | 0x2 | GV_ADDMULTI);
7160     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_COMPRATE)));
7161     SvREADONLY_on(sv);
7162   } while(0) /*@SWIG@*/;
7163   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7164     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_TAPE_SPLITSIZE", TRUE | 0x2 | GV_ADDMULTI);
7165     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_TAPE_SPLITSIZE)));
7166     SvREADONLY_on(sv);
7167   } while(0) /*@SWIG@*/;
7168   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7169     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_FALLBACK_SPLITSIZE", TRUE | 0x2 | GV_ADDMULTI);
7170     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_FALLBACK_SPLITSIZE)));
7171     SvREADONLY_on(sv);
7172   } while(0) /*@SWIG@*/;
7173   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7174     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SPLIT_DISKBUFFER", TRUE | 0x2 | GV_ADDMULTI);
7175     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SPLIT_DISKBUFFER)));
7176     SvREADONLY_on(sv);
7177   } while(0) /*@SWIG@*/;
7178   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7179     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_RECORD", TRUE | 0x2 | GV_ADDMULTI);
7180     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_RECORD)));
7181     SvREADONLY_on(sv);
7182   } while(0) /*@SWIG@*/;
7183   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7184     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SKIP_INCR", TRUE | 0x2 | GV_ADDMULTI);
7185     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SKIP_INCR)));
7186     SvREADONLY_on(sv);
7187   } while(0) /*@SWIG@*/;
7188   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7189     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SKIP_FULL", TRUE | 0x2 | GV_ADDMULTI);
7190     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SKIP_FULL)));
7191     SvREADONLY_on(sv);
7192   } while(0) /*@SWIG@*/;
7193   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7194     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_HOLDINGDISK", TRUE | 0x2 | GV_ADDMULTI);
7195     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_HOLDINGDISK)));
7196     SvREADONLY_on(sv);
7197   } while(0) /*@SWIG@*/;
7198   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7199     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_KENCRYPT", TRUE | 0x2 | GV_ADDMULTI);
7200     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_KENCRYPT)));
7201     SvREADONLY_on(sv);
7202   } while(0) /*@SWIG@*/;
7203   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7204     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_IGNORE", TRUE | 0x2 | GV_ADDMULTI);
7205     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_IGNORE)));
7206     SvREADONLY_on(sv);
7207   } while(0) /*@SWIG@*/;
7208   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7209     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_INDEX", TRUE | 0x2 | GV_ADDMULTI);
7210     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_INDEX)));
7211     SvREADONLY_on(sv);
7212   } while(0) /*@SWIG@*/;
7213   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7214     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_APPLICATION", TRUE | 0x2 | GV_ADDMULTI);
7215     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_APPLICATION)));
7216     SvREADONLY_on(sv);
7217   } while(0) /*@SWIG@*/;
7218   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7219     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SCRIPTLIST", TRUE | 0x2 | GV_ADDMULTI);
7220     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SCRIPTLIST)));
7221     SvREADONLY_on(sv);
7222   } while(0) /*@SWIG@*/;
7223   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7224     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
7225     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_PROPERTY)));
7226     SvREADONLY_on(sv);
7227   } while(0) /*@SWIG@*/;
7228   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7229     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_DATA_PATH", TRUE | 0x2 | GV_ADDMULTI);
7230     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_DATA_PATH)));
7231     SvREADONLY_on(sv);
7232   } while(0) /*@SWIG@*/;
7233   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7234     SV *sv = get_sv((char*) SWIG_prefix "INTER_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
7235     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(INTER_COMMENT)));
7236     SvREADONLY_on(sv);
7237   } while(0) /*@SWIG@*/;
7238   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7239     SV *sv = get_sv((char*) SWIG_prefix "INTER_MAXUSAGE", TRUE | 0x2 | GV_ADDMULTI);
7240     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(INTER_MAXUSAGE)));
7241     SvREADONLY_on(sv);
7242   } while(0) /*@SWIG@*/;
7243   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7244     SV *sv = get_sv((char*) SWIG_prefix "HOLDING_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
7245     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLDING_COMMENT)));
7246     SvREADONLY_on(sv);
7247   } while(0) /*@SWIG@*/;
7248   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7249     SV *sv = get_sv((char*) SWIG_prefix "HOLDING_DISKDIR", TRUE | 0x2 | GV_ADDMULTI);
7250     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLDING_DISKDIR)));
7251     SvREADONLY_on(sv);
7252   } while(0) /*@SWIG@*/;
7253   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7254     SV *sv = get_sv((char*) SWIG_prefix "HOLDING_DISKSIZE", TRUE | 0x2 | GV_ADDMULTI);
7255     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLDING_DISKSIZE)));
7256     SvREADONLY_on(sv);
7257   } while(0) /*@SWIG@*/;
7258   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7259     SV *sv = get_sv((char*) SWIG_prefix "HOLDING_CHUNKSIZE", TRUE | 0x2 | GV_ADDMULTI);
7260     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLDING_CHUNKSIZE)));
7261     SvREADONLY_on(sv);
7262   } while(0) /*@SWIG@*/;
7263   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7264     SV *sv = get_sv((char*) SWIG_prefix "APPLICATION_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
7265     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(APPLICATION_COMMENT)));
7266     SvREADONLY_on(sv);
7267   } while(0) /*@SWIG@*/;
7268   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7269     SV *sv = get_sv((char*) SWIG_prefix "APPLICATION_PLUGIN", TRUE | 0x2 | GV_ADDMULTI);
7270     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(APPLICATION_PLUGIN)));
7271     SvREADONLY_on(sv);
7272   } while(0) /*@SWIG@*/;
7273   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7274     SV *sv = get_sv((char*) SWIG_prefix "APPLICATION_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
7275     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(APPLICATION_PROPERTY)));
7276     SvREADONLY_on(sv);
7277   } while(0) /*@SWIG@*/;
7278   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7279     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
7280     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_COMMENT)));
7281     SvREADONLY_on(sv);
7282   } while(0) /*@SWIG@*/;
7283   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7284     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_PLUGIN", TRUE | 0x2 | GV_ADDMULTI);
7285     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_PLUGIN)));
7286     SvREADONLY_on(sv);
7287   } while(0) /*@SWIG@*/;
7288   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7289     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
7290     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_PROPERTY)));
7291     SvREADONLY_on(sv);
7292   } while(0) /*@SWIG@*/;
7293   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7294     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_EXECUTE_ON", TRUE | 0x2 | GV_ADDMULTI);
7295     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_EXECUTE_ON)));
7296     SvREADONLY_on(sv);
7297   } while(0) /*@SWIG@*/;
7298   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7299     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_EXECUTE_WHERE", TRUE | 0x2 | GV_ADDMULTI);
7300     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_EXECUTE_WHERE)));
7301     SvREADONLY_on(sv);
7302   } while(0) /*@SWIG@*/;
7303   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7304     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_ORDER", TRUE | 0x2 | GV_ADDMULTI);
7305     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_ORDER)));
7306     SvREADONLY_on(sv);
7307   } while(0) /*@SWIG@*/;
7308   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7309     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_CONFIG_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
7310     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_CONFIG_COMMENT)));
7311     SvREADONLY_on(sv);
7312   } while(0) /*@SWIG@*/;
7313   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7314     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_CONFIG_TAPEDEV", TRUE | 0x2 | GV_ADDMULTI);
7315     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_CONFIG_TAPEDEV)));
7316     SvREADONLY_on(sv);
7317   } while(0) /*@SWIG@*/;
7318   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7319     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_CONFIG_DEVICE_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
7320     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_CONFIG_DEVICE_PROPERTY)));
7321     SvREADONLY_on(sv);
7322   } while(0) /*@SWIG@*/;
7323   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7324     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
7325     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_COMMENT)));
7326     SvREADONLY_on(sv);
7327   } while(0) /*@SWIG@*/;
7328   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7329     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_TAPEDEV", TRUE | 0x2 | GV_ADDMULTI);
7330     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_TAPEDEV)));
7331     SvREADONLY_on(sv);
7332   } while(0) /*@SWIG@*/;
7333   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7334     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_TPCHANGER", TRUE | 0x2 | GV_ADDMULTI);
7335     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_TPCHANGER)));
7336     SvREADONLY_on(sv);
7337   } while(0) /*@SWIG@*/;
7338   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7339     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_CHANGERDEV", TRUE | 0x2 | GV_ADDMULTI);
7340     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_CHANGERDEV)));
7341     SvREADONLY_on(sv);
7342   } while(0) /*@SWIG@*/;
7343   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7344     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_CHANGERFILE", TRUE | 0x2 | GV_ADDMULTI);
7345     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_CHANGERFILE)));
7346     SvREADONLY_on(sv);
7347   } while(0) /*@SWIG@*/;
7348   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7349     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
7350     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_PROPERTY)));
7351     SvREADONLY_on(sv);
7352   } while(0) /*@SWIG@*/;
7353   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7354     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_DEVICE_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
7355     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_DEVICE_PROPERTY)));
7356     SvREADONLY_on(sv);
7357   } while(0) /*@SWIG@*/;
7358   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7359     SV *sv = get_sv((char*) SWIG_prefix "HOLD_NEVER", TRUE | 0x2 | GV_ADDMULTI);
7360     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLD_NEVER)));
7361     SvREADONLY_on(sv);
7362   } while(0) /*@SWIG@*/;
7363   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7364     SV *sv = get_sv((char*) SWIG_prefix "HOLD_AUTO", TRUE | 0x2 | GV_ADDMULTI);
7365     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLD_AUTO)));
7366     SvREADONLY_on(sv);
7367   } while(0) /*@SWIG@*/;
7368   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7369     SV *sv = get_sv((char*) SWIG_prefix "HOLD_REQUIRED", TRUE | 0x2 | GV_ADDMULTI);
7370     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLD_REQUIRED)));
7371     SvREADONLY_on(sv);
7372   } while(0) /*@SWIG@*/;
7373   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7374     SV *sv = get_sv((char*) SWIG_prefix "COMP_NONE", TRUE | 0x2 | GV_ADDMULTI);
7375     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_NONE)));
7376     SvREADONLY_on(sv);
7377   } while(0) /*@SWIG@*/;
7378   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7379     SV *sv = get_sv((char*) SWIG_prefix "COMP_FAST", TRUE | 0x2 | GV_ADDMULTI);
7380     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_FAST)));
7381     SvREADONLY_on(sv);
7382   } while(0) /*@SWIG@*/;
7383   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7384     SV *sv = get_sv((char*) SWIG_prefix "COMP_BEST", TRUE | 0x2 | GV_ADDMULTI);
7385     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_BEST)));
7386     SvREADONLY_on(sv);
7387   } while(0) /*@SWIG@*/;
7388   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7389     SV *sv = get_sv((char*) SWIG_prefix "COMP_CUST", TRUE | 0x2 | GV_ADDMULTI);
7390     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_CUST)));
7391     SvREADONLY_on(sv);
7392   } while(0) /*@SWIG@*/;
7393   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7394     SV *sv = get_sv((char*) SWIG_prefix "COMP_SERVER_FAST", TRUE | 0x2 | GV_ADDMULTI);
7395     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_SERVER_FAST)));
7396     SvREADONLY_on(sv);
7397   } while(0) /*@SWIG@*/;
7398   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7399     SV *sv = get_sv((char*) SWIG_prefix "COMP_SERVER_BEST", TRUE | 0x2 | GV_ADDMULTI);
7400     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_SERVER_BEST)));
7401     SvREADONLY_on(sv);
7402   } while(0) /*@SWIG@*/;
7403   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7404     SV *sv = get_sv((char*) SWIG_prefix "COMP_SERVER_CUST", TRUE | 0x2 | GV_ADDMULTI);
7405     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_SERVER_CUST)));
7406     SvREADONLY_on(sv);
7407   } while(0) /*@SWIG@*/;
7408   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7409     SV *sv = get_sv((char*) SWIG_prefix "ENCRYPT_NONE", TRUE | 0x2 | GV_ADDMULTI);
7410     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ENCRYPT_NONE)));
7411     SvREADONLY_on(sv);
7412   } while(0) /*@SWIG@*/;
7413   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7414     SV *sv = get_sv((char*) SWIG_prefix "ENCRYPT_CUST", TRUE | 0x2 | GV_ADDMULTI);
7415     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ENCRYPT_CUST)));
7416     SvREADONLY_on(sv);
7417   } while(0) /*@SWIG@*/;
7418   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7419     SV *sv = get_sv((char*) SWIG_prefix "ENCRYPT_SERV_CUST", TRUE | 0x2 | GV_ADDMULTI);
7420     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ENCRYPT_SERV_CUST)));
7421     SvREADONLY_on(sv);
7422   } while(0) /*@SWIG@*/;
7423   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7424     SV *sv = get_sv((char*) SWIG_prefix "DS_SKIP", TRUE | 0x2 | GV_ADDMULTI);
7425     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_SKIP)));
7426     SvREADONLY_on(sv);
7427   } while(0) /*@SWIG@*/;
7428   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7429     SV *sv = get_sv((char*) SWIG_prefix "DS_STANDARD", TRUE | 0x2 | GV_ADDMULTI);
7430     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_STANDARD)));
7431     SvREADONLY_on(sv);
7432   } while(0) /*@SWIG@*/;
7433   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7434     SV *sv = get_sv((char*) SWIG_prefix "DS_NOFULL", TRUE | 0x2 | GV_ADDMULTI);
7435     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_NOFULL)));
7436     SvREADONLY_on(sv);
7437   } while(0) /*@SWIG@*/;
7438   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7439     SV *sv = get_sv((char*) SWIG_prefix "DS_NOINC", TRUE | 0x2 | GV_ADDMULTI);
7440     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_NOINC)));
7441     SvREADONLY_on(sv);
7442   } while(0) /*@SWIG@*/;
7443   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7444     SV *sv = get_sv((char*) SWIG_prefix "DS_4", TRUE | 0x2 | GV_ADDMULTI);
7445     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_4)));
7446     SvREADONLY_on(sv);
7447   } while(0) /*@SWIG@*/;
7448   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7449     SV *sv = get_sv((char*) SWIG_prefix "DS_5", TRUE | 0x2 | GV_ADDMULTI);
7450     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_5)));
7451     SvREADONLY_on(sv);
7452   } while(0) /*@SWIG@*/;
7453   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7454     SV *sv = get_sv((char*) SWIG_prefix "DS_HANOI", TRUE | 0x2 | GV_ADDMULTI);
7455     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_HANOI)));
7456     SvREADONLY_on(sv);
7457   } while(0) /*@SWIG@*/;
7458   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7459     SV *sv = get_sv((char*) SWIG_prefix "DS_INCRONLY", TRUE | 0x2 | GV_ADDMULTI);
7460     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_INCRONLY)));
7461     SvREADONLY_on(sv);
7462   } while(0) /*@SWIG@*/;
7463   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7464     SV *sv = get_sv((char*) SWIG_prefix "ES_CLIENT", TRUE | 0x2 | GV_ADDMULTI);
7465     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ES_CLIENT)));
7466     SvREADONLY_on(sv);
7467   } while(0) /*@SWIG@*/;
7468   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7469     SV *sv = get_sv((char*) SWIG_prefix "ES_SERVER", TRUE | 0x2 | GV_ADDMULTI);
7470     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ES_SERVER)));
7471     SvREADONLY_on(sv);
7472   } while(0) /*@SWIG@*/;
7473   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7474     SV *sv = get_sv((char*) SWIG_prefix "ES_CALCSIZE", TRUE | 0x2 | GV_ADDMULTI);
7475     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ES_CALCSIZE)));
7476     SvREADONLY_on(sv);
7477   } while(0) /*@SWIG@*/;
7478   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7479     SV *sv = get_sv((char*) SWIG_prefix "AL_OTHER_CONFIG", TRUE | 0x2 | GV_ADDMULTI);
7480     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(AL_OTHER_CONFIG)));
7481     SvREADONLY_on(sv);
7482   } while(0) /*@SWIG@*/;
7483   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7484     SV *sv = get_sv((char*) SWIG_prefix "AL_NON_AMANDA", TRUE | 0x2 | GV_ADDMULTI);
7485     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(AL_NON_AMANDA)));
7486     SvREADONLY_on(sv);
7487   } while(0) /*@SWIG@*/;
7488   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7489     SV *sv = get_sv((char*) SWIG_prefix "AL_VOLUME_ERROR", TRUE | 0x2 | GV_ADDMULTI);
7490     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(AL_VOLUME_ERROR)));
7491     SvREADONLY_on(sv);
7492   } while(0) /*@SWIG@*/;
7493   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7494     SV *sv = get_sv((char*) SWIG_prefix "AL_EMPTY", TRUE | 0x2 | GV_ADDMULTI);
7495     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(AL_EMPTY)));
7496     SvREADONLY_on(sv);
7497   } while(0) /*@SWIG@*/;
7498   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7499     SV *sv = get_sv((char*) SWIG_prefix "ALGO_FIRST", TRUE | 0x2 | GV_ADDMULTI);
7500     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_FIRST)));
7501     SvREADONLY_on(sv);
7502   } while(0) /*@SWIG@*/;
7503   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7504     SV *sv = get_sv((char*) SWIG_prefix "ALGO_FIRSTFIT", TRUE | 0x2 | GV_ADDMULTI);
7505     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_FIRSTFIT)));
7506     SvREADONLY_on(sv);
7507   } while(0) /*@SWIG@*/;
7508   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7509     SV *sv = get_sv((char*) SWIG_prefix "ALGO_LARGEST", TRUE | 0x2 | GV_ADDMULTI);
7510     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_LARGEST)));
7511     SvREADONLY_on(sv);
7512   } while(0) /*@SWIG@*/;
7513   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7514     SV *sv = get_sv((char*) SWIG_prefix "ALGO_LARGESTFIT", TRUE | 0x2 | GV_ADDMULTI);
7515     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_LARGESTFIT)));
7516     SvREADONLY_on(sv);
7517   } while(0) /*@SWIG@*/;
7518   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7519     SV *sv = get_sv((char*) SWIG_prefix "ALGO_SMALLEST", TRUE | 0x2 | GV_ADDMULTI);
7520     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_SMALLEST)));
7521     SvREADONLY_on(sv);
7522   } while(0) /*@SWIG@*/;
7523   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7524     SV *sv = get_sv((char*) SWIG_prefix "ALGO_LAST", TRUE | 0x2 | GV_ADDMULTI);
7525     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_LAST)));
7526     SvREADONLY_on(sv);
7527   } while(0) /*@SWIG@*/;
7528   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7529     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_DLE_AMCHECK", TRUE | 0x2 | GV_ADDMULTI);
7530     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_DLE_AMCHECK)));
7531     SvREADONLY_on(sv);
7532   } while(0) /*@SWIG@*/;
7533   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7534     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_HOST_AMCHECK", TRUE | 0x2 | GV_ADDMULTI);
7535     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_HOST_AMCHECK)));
7536     SvREADONLY_on(sv);
7537   } while(0) /*@SWIG@*/;
7538   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7539     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_DLE_AMCHECK", TRUE | 0x2 | GV_ADDMULTI);
7540     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_DLE_AMCHECK)));
7541     SvREADONLY_on(sv);
7542   } while(0) /*@SWIG@*/;
7543   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7544     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_HOST_AMCHECK", TRUE | 0x2 | GV_ADDMULTI);
7545     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_HOST_AMCHECK)));
7546     SvREADONLY_on(sv);
7547   } while(0) /*@SWIG@*/;
7548   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7549     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_DLE_ESTIMATE", TRUE | 0x2 | GV_ADDMULTI);
7550     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_DLE_ESTIMATE)));
7551     SvREADONLY_on(sv);
7552   } while(0) /*@SWIG@*/;
7553   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7554     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_HOST_ESTIMATE", TRUE | 0x2 | GV_ADDMULTI);
7555     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_HOST_ESTIMATE)));
7556     SvREADONLY_on(sv);
7557   } while(0) /*@SWIG@*/;
7558   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7559     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_DLE_ESTIMATE", TRUE | 0x2 | GV_ADDMULTI);
7560     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_DLE_ESTIMATE)));
7561     SvREADONLY_on(sv);
7562   } while(0) /*@SWIG@*/;
7563   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7564     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_HOST_ESTIMATE", TRUE | 0x2 | GV_ADDMULTI);
7565     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_HOST_ESTIMATE)));
7566     SvREADONLY_on(sv);
7567   } while(0) /*@SWIG@*/;
7568   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7569     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_DLE_BACKUP", TRUE | 0x2 | GV_ADDMULTI);
7570     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_DLE_BACKUP)));
7571     SvREADONLY_on(sv);
7572   } while(0) /*@SWIG@*/;
7573   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7574     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_HOST_BACKUP", TRUE | 0x2 | GV_ADDMULTI);
7575     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_HOST_BACKUP)));
7576     SvREADONLY_on(sv);
7577   } while(0) /*@SWIG@*/;
7578   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7579     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_DLE_BACKUP", TRUE | 0x2 | GV_ADDMULTI);
7580     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_DLE_BACKUP)));
7581     SvREADONLY_on(sv);
7582   } while(0) /*@SWIG@*/;
7583   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7584     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_HOST_BACKUP", TRUE | 0x2 | GV_ADDMULTI);
7585     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_HOST_BACKUP)));
7586     SvREADONLY_on(sv);
7587   } while(0) /*@SWIG@*/;
7588   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7589     SV *sv = get_sv((char*) SWIG_prefix "SEND_AMREPORT_ALL", TRUE | 0x2 | GV_ADDMULTI);
7590     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SEND_AMREPORT_ALL)));
7591     SvREADONLY_on(sv);
7592   } while(0) /*@SWIG@*/;
7593   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7594     SV *sv = get_sv((char*) SWIG_prefix "SEND_AMREPORT_STRANGE", TRUE | 0x2 | GV_ADDMULTI);
7595     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SEND_AMREPORT_STRANGE)));
7596     SvREADONLY_on(sv);
7597   } while(0) /*@SWIG@*/;
7598   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7599     SV *sv = get_sv((char*) SWIG_prefix "SEND_AMREPORT_ERROR", TRUE | 0x2 | GV_ADDMULTI);
7600     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SEND_AMREPORT_ERROR)));
7601     SvREADONLY_on(sv);
7602   } while(0) /*@SWIG@*/;
7603   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7604     SV *sv = get_sv((char*) SWIG_prefix "SEND_AMREPORT_NEVER", TRUE | 0x2 | GV_ADDMULTI);
7605     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SEND_AMREPORT_NEVER)));
7606     SvREADONLY_on(sv);
7607   } while(0) /*@SWIG@*/;
7608   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7609     SV *sv = get_sv((char*) SWIG_prefix "DATA_PATH_AMANDA", TRUE | 0x2 | GV_ADDMULTI);
7610     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DATA_PATH_AMANDA)));
7611     SvREADONLY_on(sv);
7612   } while(0) /*@SWIG@*/;
7613   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7614     SV *sv = get_sv((char*) SWIG_prefix "DATA_PATH_DIRECTTCP", TRUE | 0x2 | GV_ADDMULTI);
7615     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DATA_PATH_DIRECTTCP)));
7616     SvREADONLY_on(sv);
7617   } while(0) /*@SWIG@*/;
7618   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7619     SV *sv = get_sv((char*) SWIG_prefix "CFGERR_OK", TRUE | 0x2 | GV_ADDMULTI);
7620     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CFGERR_OK)));
7621     SvREADONLY_on(sv);
7622   } while(0) /*@SWIG@*/;
7623   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7624     SV *sv = get_sv((char*) SWIG_prefix "CFGERR_WARNINGS", TRUE | 0x2 | GV_ADDMULTI);
7625     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CFGERR_WARNINGS)));
7626     SvREADONLY_on(sv);
7627   } while(0) /*@SWIG@*/;
7628   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7629     SV *sv = get_sv((char*) SWIG_prefix "CFGERR_ERRORS", TRUE | 0x2 | GV_ADDMULTI);
7630     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CFGERR_ERRORS)));
7631     SvREADONLY_on(sv);
7632   } while(0) /*@SWIG@*/;
7633   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7634     SV *sv = get_sv((char*) SWIG_prefix "CONFIG_INIT_EXPLICIT_NAME", TRUE | 0x2 | GV_ADDMULTI);
7635     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONFIG_INIT_EXPLICIT_NAME)));
7636     SvREADONLY_on(sv);
7637   } while(0) /*@SWIG@*/;
7638   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7639     SV *sv = get_sv((char*) SWIG_prefix "CONFIG_INIT_USE_CWD", TRUE | 0x2 | GV_ADDMULTI);
7640     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONFIG_INIT_USE_CWD)));
7641     SvREADONLY_on(sv);
7642   } while(0) /*@SWIG@*/;
7643   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7644     SV *sv = get_sv((char*) SWIG_prefix "CONFIG_INIT_CLIENT", TRUE | 0x2 | GV_ADDMULTI);
7645     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONFIG_INIT_CLIENT)));
7646     SvREADONLY_on(sv);
7647   } while(0) /*@SWIG@*/;
7648   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7649     SV *sv = get_sv((char*) SWIG_prefix "CONFIG_INIT_OVERLAY", TRUE | 0x2 | GV_ADDMULTI);
7650     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONFIG_INIT_OVERLAY)));
7651     SvREADONLY_on(sv);
7652   } while(0) /*@SWIG@*/;
7653   ST(0) = &PL_sv_yes;
7654   XSRETURN(1);
7655 }
7656