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