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);
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     int argvi = 0;
4812     dXSARGS;
4813
4814     if ((items < 0) || (items > 0)) {
4815       SWIG_croak("Usage: dump_configuration();");
4816     }
4817     dump_configuration();
4818     ST(argvi) = sv_newmortal();
4819     XSRETURN(argvi);
4820   fail:
4821     SWIG_croak_null();
4822   }
4823 }
4824
4825
4826 XS(_wrap_config_dir_relative) {
4827   {
4828     char *arg1 = (char *) 0 ;
4829     int res1 ;
4830     char *buf1 = 0 ;
4831     int alloc1 = 0 ;
4832     int argvi = 0;
4833     char *result = 0 ;
4834     dXSARGS;
4835
4836     if ((items < 1) || (items > 1)) {
4837       SWIG_croak("Usage: config_dir_relative(filename);");
4838     }
4839     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
4840     if (!SWIG_IsOK(res1)) {
4841       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "config_dir_relative" "', argument " "1"" of type '" "char *""'");
4842     }
4843     arg1 = (char *)(buf1);
4844     result = (char *)config_dir_relative(arg1);
4845     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4846     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4847     free((char*)result);
4848     XSRETURN(argvi);
4849   fail:
4850     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4851     SWIG_croak_null();
4852   }
4853 }
4854
4855
4856 XS(_wrap_taperalgo2str) {
4857   {
4858     taperalgo_t arg1 ;
4859     int argvi = 0;
4860     char *result = 0 ;
4861     dXSARGS;
4862
4863     if ((items < 1) || (items > 1)) {
4864       SWIG_croak("Usage: taperalgo2str(taperalgo);");
4865     }
4866     {
4867       if (sizeof(signed int) == 1) {
4868         arg1 = amglue_SvI8(ST(0));
4869       } else if (sizeof(signed int) == 2) {
4870         arg1 = amglue_SvI16(ST(0));
4871       } else if (sizeof(signed int) == 4) {
4872         arg1 = amglue_SvI32(ST(0));
4873       } else if (sizeof(signed int) == 8) {
4874         arg1 = amglue_SvI64(ST(0));
4875       } else {
4876         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4877       }
4878     }
4879     result = (char *)taperalgo2str(arg1);
4880     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4881
4882     XSRETURN(argvi);
4883   fail:
4884
4885     SWIG_croak_null();
4886   }
4887 }
4888
4889
4890 XS(_wrap_find_multiplier) {
4891   {
4892     char *arg1 = (char *) 0 ;
4893     int res1 ;
4894     char *buf1 = 0 ;
4895     int alloc1 = 0 ;
4896     int argvi = 0;
4897     gint64 result;
4898     dXSARGS;
4899
4900     if ((items < 1) || (items > 1)) {
4901       SWIG_croak("Usage: find_multiplier(casestr);");
4902     }
4903     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
4904     if (!SWIG_IsOK(res1)) {
4905       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "find_multiplier" "', argument " "1"" of type '" "char *""'");
4906     }
4907     arg1 = (char *)(buf1);
4908     result = find_multiplier(arg1);
4909     {
4910       SV *for_stack;
4911       SP += argvi; PUTBACK;
4912       for_stack = sv_2mortal(amglue_newSVi64(result));
4913       SPAGAIN; SP -= argvi;
4914       ST(argvi) = for_stack;
4915       argvi++;
4916     }
4917     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4918     XSRETURN(argvi);
4919   fail:
4920     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4921     SWIG_croak_null();
4922   }
4923 }
4924
4925
4926 XS(_wrap_C_string_to_boolean) {
4927   {
4928     char *arg1 = (char *) 0 ;
4929     int res1 ;
4930     char *buf1 = 0 ;
4931     int alloc1 = 0 ;
4932     int argvi = 0;
4933     int result;
4934     dXSARGS;
4935
4936     if ((items < 1) || (items > 1)) {
4937       SWIG_croak("Usage: C_string_to_boolean(str);");
4938     }
4939     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
4940     if (!SWIG_IsOK(res1)) {
4941       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "C_string_to_boolean" "', argument " "1"" of type '" "char const *""'");
4942     }
4943     arg1 = (char *)(buf1);
4944     result = (int)string_to_boolean((char const *)arg1);
4945     {
4946       SV *for_stack;
4947       SP += argvi; PUTBACK;
4948       for_stack = sv_2mortal(amglue_newSVi64(result));
4949       SPAGAIN; SP -= argvi;
4950       ST(argvi) = for_stack;
4951       argvi++;
4952     }
4953     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4954     XSRETURN(argvi);
4955   fail:
4956     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4957     SWIG_croak_null();
4958   }
4959 }
4960
4961
4962 XS(_wrap_amandaify_property_name) {
4963   {
4964     gchar *arg1 = (gchar *) 0 ;
4965     int res1 ;
4966     char *buf1 = 0 ;
4967     int alloc1 = 0 ;
4968     int argvi = 0;
4969     gchar *result = 0 ;
4970     dXSARGS;
4971
4972     if ((items < 1) || (items > 1)) {
4973       SWIG_croak("Usage: amandaify_property_name(name);");
4974     }
4975     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
4976     if (!SWIG_IsOK(res1)) {
4977       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "amandaify_property_name" "', argument " "1"" of type '" "gchar const *""'");
4978     }
4979     arg1 = (gchar *)(buf1);
4980     result = (gchar *)amandaify_property_name((char const *)arg1);
4981     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4982     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4983     XSRETURN(argvi);
4984   fail:
4985     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4986     SWIG_croak_null();
4987   }
4988 }
4989
4990
4991
4992 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4993
4994 static swig_type_info _swigt__p_application_t = {"_p_application_t", "application_t *", 0, 0, (void*)0, 0};
4995 static swig_type_info _swigt__p_changer_config_t = {"_p_changer_config_t", "changer_config_t *", 0, 0, (void*)0, 0};
4996 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
4997 static swig_type_info _swigt__p_config_overrides_t = {"_p_config_overrides_t", "config_overrides_t *", 0, 0, (void*)0, 0};
4998 static swig_type_info _swigt__p_device_config_t = {"_p_device_config_t", "device_config_t *", 0, 0, (void*)0, 0};
4999 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
5000 static swig_type_info _swigt__p_dumptype_t = {"_p_dumptype_t", "dumptype_t *", 0, 0, (void*)0, 0};
5001 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
5002 static swig_type_info _swigt__p_holdingdisk_t = {"_p_holdingdisk_t", "holdingdisk_t *", 0, 0, (void*)0, 0};
5003 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};
5004 static swig_type_info _swigt__p_interactivity_t = {"_p_interactivity_t", "interactivity_t *", 0, 0, (void*)0, 0};
5005 static swig_type_info _swigt__p_interface_t = {"_p_interface_t", "interface_t *", 0, 0, (void*)0, 0};
5006 static swig_type_info _swigt__p_p_GSList = {"_p_p_GSList", "GSList **", 0, 0, (void*)0, 0};
5007 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
5008 static swig_type_info _swigt__p_pp_script_t = {"_p_pp_script_t", "pp_script_t *", 0, 0, (void*)0, 0};
5009 static swig_type_info _swigt__p_taperscan_t = {"_p_taperscan_t", "taperscan_t *", 0, 0, (void*)0, 0};
5010 static swig_type_info _swigt__p_tapetype_t = {"_p_tapetype_t", "tapetype_t *", 0, 0, (void*)0, 0};
5011 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
5012
5013 static swig_type_info *swig_type_initial[] = {
5014   &_swigt__p_application_t,
5015   &_swigt__p_changer_config_t,
5016   &_swigt__p_char,
5017   &_swigt__p_config_overrides_t,
5018   &_swigt__p_device_config_t,
5019   &_swigt__p_double,
5020   &_swigt__p_dumptype_t,
5021   &_swigt__p_float,
5022   &_swigt__p_holdingdisk_t,
5023   &_swigt__p_int,
5024   &_swigt__p_interactivity_t,
5025   &_swigt__p_interface_t,
5026   &_swigt__p_p_GSList,
5027   &_swigt__p_p_char,
5028   &_swigt__p_pp_script_t,
5029   &_swigt__p_taperscan_t,
5030   &_swigt__p_tapetype_t,
5031   &_swigt__p_unsigned_char,
5032 };
5033
5034 static swig_cast_info _swigc__p_application_t[] = {  {&_swigt__p_application_t, 0, 0, 0},{0, 0, 0, 0}};
5035 static swig_cast_info _swigc__p_changer_config_t[] = {  {&_swigt__p_changer_config_t, 0, 0, 0},{0, 0, 0, 0}};
5036 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
5037 static swig_cast_info _swigc__p_config_overrides_t[] = {  {&_swigt__p_config_overrides_t, 0, 0, 0},{0, 0, 0, 0}};
5038 static swig_cast_info _swigc__p_device_config_t[] = {  {&_swigt__p_device_config_t, 0, 0, 0},{0, 0, 0, 0}};
5039 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
5040 static swig_cast_info _swigc__p_dumptype_t[] = {  {&_swigt__p_dumptype_t, 0, 0, 0},{0, 0, 0, 0}};
5041 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
5042 static swig_cast_info _swigc__p_holdingdisk_t[] = {  {&_swigt__p_holdingdisk_t, 0, 0, 0},{0, 0, 0, 0}};
5043 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
5044 static swig_cast_info _swigc__p_interactivity_t[] = {  {&_swigt__p_interactivity_t, 0, 0, 0},{0, 0, 0, 0}};
5045 static swig_cast_info _swigc__p_interface_t[] = {  {&_swigt__p_interface_t, 0, 0, 0},{0, 0, 0, 0}};
5046 static swig_cast_info _swigc__p_p_GSList[] = {  {&_swigt__p_p_GSList, 0, 0, 0},{0, 0, 0, 0}};
5047 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
5048 static swig_cast_info _swigc__p_pp_script_t[] = {  {&_swigt__p_pp_script_t, 0, 0, 0},{0, 0, 0, 0}};
5049 static swig_cast_info _swigc__p_taperscan_t[] = {  {&_swigt__p_taperscan_t, 0, 0, 0},{0, 0, 0, 0}};
5050 static swig_cast_info _swigc__p_tapetype_t[] = {  {&_swigt__p_tapetype_t, 0, 0, 0},{0, 0, 0, 0}};
5051 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
5052
5053 static swig_cast_info *swig_cast_initial[] = {
5054   _swigc__p_application_t,
5055   _swigc__p_changer_config_t,
5056   _swigc__p_char,
5057   _swigc__p_config_overrides_t,
5058   _swigc__p_device_config_t,
5059   _swigc__p_double,
5060   _swigc__p_dumptype_t,
5061   _swigc__p_float,
5062   _swigc__p_holdingdisk_t,
5063   _swigc__p_int,
5064   _swigc__p_interactivity_t,
5065   _swigc__p_interface_t,
5066   _swigc__p_p_GSList,
5067   _swigc__p_p_char,
5068   _swigc__p_pp_script_t,
5069   _swigc__p_taperscan_t,
5070   _swigc__p_tapetype_t,
5071   _swigc__p_unsigned_char,
5072 };
5073
5074
5075 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
5076
5077 static swig_constant_info swig_constants[] = {
5078 {0,0,0,0,0,0}
5079 };
5080 #ifdef __cplusplus
5081 }
5082 #endif
5083 static swig_variable_info swig_variables[] = {
5084     { "Amanda::Configc::debug_amandad", MAGIC_CLASS _wrap_debug_amandad_set, MAGIC_CLASS _wrap_debug_amandad_get,0 },
5085     { "Amanda::Configc::debug_recovery", MAGIC_CLASS _wrap_debug_recovery_set, MAGIC_CLASS _wrap_debug_recovery_get,0 },
5086     { "Amanda::Configc::debug_amidxtaped", MAGIC_CLASS _wrap_debug_amidxtaped_set, MAGIC_CLASS _wrap_debug_amidxtaped_get,0 },
5087     { "Amanda::Configc::debug_amindexd", MAGIC_CLASS _wrap_debug_amindexd_set, MAGIC_CLASS _wrap_debug_amindexd_get,0 },
5088     { "Amanda::Configc::debug_amrecover", MAGIC_CLASS _wrap_debug_amrecover_set, MAGIC_CLASS _wrap_debug_amrecover_get,0 },
5089     { "Amanda::Configc::debug_auth", MAGIC_CLASS _wrap_debug_auth_set, MAGIC_CLASS _wrap_debug_auth_get,0 },
5090     { "Amanda::Configc::debug_event", MAGIC_CLASS _wrap_debug_event_set, MAGIC_CLASS _wrap_debug_event_get,0 },
5091     { "Amanda::Configc::debug_holding", MAGIC_CLASS _wrap_debug_holding_set, MAGIC_CLASS _wrap_debug_holding_get,0 },
5092     { "Amanda::Configc::debug_protocol", MAGIC_CLASS _wrap_debug_protocol_set, MAGIC_CLASS _wrap_debug_protocol_get,0 },
5093     { "Amanda::Configc::debug_planner", MAGIC_CLASS _wrap_debug_planner_set, MAGIC_CLASS _wrap_debug_planner_get,0 },
5094     { "Amanda::Configc::debug_driver", MAGIC_CLASS _wrap_debug_driver_set, MAGIC_CLASS _wrap_debug_driver_get,0 },
5095     { "Amanda::Configc::debug_dumper", MAGIC_CLASS _wrap_debug_dumper_set, MAGIC_CLASS _wrap_debug_dumper_get,0 },
5096     { "Amanda::Configc::debug_chunker", MAGIC_CLASS _wrap_debug_chunker_set, MAGIC_CLASS _wrap_debug_chunker_get,0 },
5097     { "Amanda::Configc::debug_taper", MAGIC_CLASS _wrap_debug_taper_set, MAGIC_CLASS _wrap_debug_taper_get,0 },
5098     { "Amanda::Configc::debug_selfcheck", MAGIC_CLASS _wrap_debug_selfcheck_set, MAGIC_CLASS _wrap_debug_selfcheck_get,0 },
5099     { "Amanda::Configc::debug_sendsize", MAGIC_CLASS _wrap_debug_sendsize_set, MAGIC_CLASS _wrap_debug_sendsize_get,0 },
5100     { "Amanda::Configc::debug_sendbackup", MAGIC_CLASS _wrap_debug_sendbackup_set, MAGIC_CLASS _wrap_debug_sendbackup_get,0 },
5101 {0,0,0,0}
5102 };
5103 static swig_command_info swig_commands[] = {
5104 {"Amanda::Configc::data_path_from_string", _wrap_data_path_from_string},
5105 {"Amanda::Configc::getconf", _wrap_getconf},
5106 {"Amanda::Configc::getconf_seen", _wrap_getconf_seen},
5107 {"Amanda::Configc::getconf_linenum", _wrap_getconf_linenum},
5108 {"Amanda::Configc::getconf_byname", _wrap_getconf_byname},
5109 {"Amanda::Configc::getconf_list", _wrap_getconf_list},
5110 {"Amanda::Configc::getconf_byname_strs", _wrap_getconf_byname_strs},
5111 {"Amanda::Configc::lookup_tapetype", _wrap_lookup_tapetype},
5112 {"Amanda::Configc::tapetype_getconf", _wrap_tapetype_getconf},
5113 {"Amanda::Configc::tapetype_name", _wrap_tapetype_name},
5114 {"Amanda::Configc::tapetype_seen", _wrap_tapetype_seen},
5115 {"Amanda::Configc::lookup_dumptype", _wrap_lookup_dumptype},
5116 {"Amanda::Configc::dumptype_getconf", _wrap_dumptype_getconf},
5117 {"Amanda::Configc::dumptype_name", _wrap_dumptype_name},
5118 {"Amanda::Configc::dumptype_seen", _wrap_dumptype_seen},
5119 {"Amanda::Configc::lookup_interface", _wrap_lookup_interface},
5120 {"Amanda::Configc::interface_getconf", _wrap_interface_getconf},
5121 {"Amanda::Configc::interface_name", _wrap_interface_name},
5122 {"Amanda::Configc::interface_seen", _wrap_interface_seen},
5123 {"Amanda::Configc::lookup_holdingdisk", _wrap_lookup_holdingdisk},
5124 {"Amanda::Configc::getconf_holdingdisks", _wrap_getconf_holdingdisks},
5125 {"Amanda::Configc::holdingdisk_getconf", _wrap_holdingdisk_getconf},
5126 {"Amanda::Configc::holdingdisk_name", _wrap_holdingdisk_name},
5127 {"Amanda::Configc::holdingdisk_seen", _wrap_holdingdisk_seen},
5128 {"Amanda::Configc::lookup_application", _wrap_lookup_application},
5129 {"Amanda::Configc::application_getconf", _wrap_application_getconf},
5130 {"Amanda::Configc::application_name", _wrap_application_name},
5131 {"Amanda::Configc::application_seen", _wrap_application_seen},
5132 {"Amanda::Configc::lookup_pp_script", _wrap_lookup_pp_script},
5133 {"Amanda::Configc::pp_script_getconf", _wrap_pp_script_getconf},
5134 {"Amanda::Configc::pp_script_name", _wrap_pp_script_name},
5135 {"Amanda::Configc::pp_script_seen", _wrap_pp_script_seen},
5136 {"Amanda::Configc::lookup_device_config", _wrap_lookup_device_config},
5137 {"Amanda::Configc::device_config_getconf", _wrap_device_config_getconf},
5138 {"Amanda::Configc::device_config_name", _wrap_device_config_name},
5139 {"Amanda::Configc::device_config_seen", _wrap_device_config_seen},
5140 {"Amanda::Configc::lookup_changer_config", _wrap_lookup_changer_config},
5141 {"Amanda::Configc::changer_config_getconf", _wrap_changer_config_getconf},
5142 {"Amanda::Configc::changer_config_name", _wrap_changer_config_name},
5143 {"Amanda::Configc::changer_config_seen", _wrap_changer_config_seen},
5144 {"Amanda::Configc::lookup_interactivity", _wrap_lookup_interactivity},
5145 {"Amanda::Configc::interactivity_getconf", _wrap_interactivity_getconf},
5146 {"Amanda::Configc::interactivity_name", _wrap_interactivity_name},
5147 {"Amanda::Configc::interactivity_seen", _wrap_interactivity_seen},
5148 {"Amanda::Configc::lookup_taperscan", _wrap_lookup_taperscan},
5149 {"Amanda::Configc::taperscan_getconf", _wrap_taperscan_getconf},
5150 {"Amanda::Configc::taperscan_name", _wrap_taperscan_name},
5151 {"Amanda::Configc::taperscan_seen", _wrap_taperscan_seen},
5152 {"Amanda::Configc::getconf_unit_divisor", _wrap_getconf_unit_divisor},
5153 {"Amanda::Configc::config_init", _wrap_config_init},
5154 {"Amanda::Configc::config_uninit", _wrap_config_uninit},
5155 {"Amanda::Configc::get_config_options", _wrap_get_config_options},
5156 {"Amanda::Configc::get_config_name", _wrap_get_config_name},
5157 {"Amanda::Configc::get_config_dir", _wrap_get_config_dir},
5158 {"Amanda::Configc::get_config_filename", _wrap_get_config_filename},
5159 {"Amanda::Configc::config_print_errors", _wrap_config_print_errors},
5160 {"Amanda::Configc::config_clear_errors", _wrap_config_clear_errors},
5161 {"Amanda::Configc::config_errors", _wrap_config_errors},
5162 {"Amanda::Configc::new_config_overrides", _wrap_new_config_overrides},
5163 {"Amanda::Configc::free_config_overrides", _wrap_free_config_overrides},
5164 {"Amanda::Configc::add_config_override", _wrap_add_config_override},
5165 {"Amanda::Configc::add_config_override_opt", _wrap_add_config_override_opt},
5166 {"Amanda::Configc::set_config_overrides", _wrap_set_config_overrides},
5167 {"Amanda::Configc::dump_configuration", _wrap_dump_configuration},
5168 {"Amanda::Configc::config_dir_relative", _wrap_config_dir_relative},
5169 {"Amanda::Configc::taperalgo2str", _wrap_taperalgo2str},
5170 {"Amanda::Configc::find_multiplier", _wrap_find_multiplier},
5171 {"Amanda::Configc::C_string_to_boolean", _wrap_C_string_to_boolean},
5172 {"Amanda::Configc::amandaify_property_name", _wrap_amandaify_property_name},
5173 {0,0}
5174 };
5175 /* -----------------------------------------------------------------------------
5176  * Type initialization:
5177  * This problem is tough by the requirement that no dynamic
5178  * memory is used. Also, since swig_type_info structures store pointers to
5179  * swig_cast_info structures and swig_cast_info structures store pointers back
5180  * to swig_type_info structures, we need some lookup code at initialization.
5181  * The idea is that swig generates all the structures that are needed.
5182  * The runtime then collects these partially filled structures.
5183  * The SWIG_InitializeModule function takes these initial arrays out of
5184  * swig_module, and does all the lookup, filling in the swig_module.types
5185  * array with the correct data and linking the correct swig_cast_info
5186  * structures together.
5187  *
5188  * The generated swig_type_info structures are assigned staticly to an initial
5189  * array. We just loop through that array, and handle each type individually.
5190  * First we lookup if this type has been already loaded, and if so, use the
5191  * loaded structure instead of the generated one. Then we have to fill in the
5192  * cast linked list. The cast data is initially stored in something like a
5193  * two-dimensional array. Each row corresponds to a type (there are the same
5194  * number of rows as there are in the swig_type_initial array). Each entry in
5195  * a column is one of the swig_cast_info structures for that type.
5196  * The cast_initial array is actually an array of arrays, because each row has
5197  * a variable number of columns. So to actually build the cast linked list,
5198  * we find the array of casts associated with the type, and loop through it
5199  * adding the casts to the list. The one last trick we need to do is making
5200  * sure the type pointer in the swig_cast_info struct is correct.
5201  *
5202  * First off, we lookup the cast->type name to see if it is already loaded.
5203  * There are three cases to handle:
5204  *  1) If the cast->type has already been loaded AND the type we are adding
5205  *     casting info to has not been loaded (it is in this module), THEN we
5206  *     replace the cast->type pointer with the type pointer that has already
5207  *     been loaded.
5208  *  2) If BOTH types (the one we are adding casting info to, and the
5209  *     cast->type) are loaded, THEN the cast info has already been loaded by
5210  *     the previous module so we just ignore it.
5211  *  3) Finally, if cast->type has not already been loaded, then we add that
5212  *     swig_cast_info to the linked list (because the cast->type) pointer will
5213  *     be correct.
5214  * ----------------------------------------------------------------------------- */
5215
5216 #ifdef __cplusplus
5217 extern "C" {
5218 #if 0
5219 } /* c-mode */
5220 #endif
5221 #endif
5222
5223 #if 0
5224 #define SWIGRUNTIME_DEBUG
5225 #endif
5226
5227
5228 SWIGRUNTIME void
5229 SWIG_InitializeModule(void *clientdata) {
5230   size_t i;
5231   swig_module_info *module_head, *iter;
5232   int found, init;
5233
5234   clientdata = clientdata;
5235
5236   /* check to see if the circular list has been setup, if not, set it up */
5237   if (swig_module.next==0) {
5238     /* Initialize the swig_module */
5239     swig_module.type_initial = swig_type_initial;
5240     swig_module.cast_initial = swig_cast_initial;
5241     swig_module.next = &swig_module;
5242     init = 1;
5243   } else {
5244     init = 0;
5245   }
5246
5247   /* Try and load any already created modules */
5248   module_head = SWIG_GetModule(clientdata);
5249   if (!module_head) {
5250     /* This is the first module loaded for this interpreter */
5251     /* so set the swig module into the interpreter */
5252     SWIG_SetModule(clientdata, &swig_module);
5253     module_head = &swig_module;
5254   } else {
5255     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
5256     found=0;
5257     iter=module_head;
5258     do {
5259       if (iter==&swig_module) {
5260         found=1;
5261         break;
5262       }
5263       iter=iter->next;
5264     } while (iter!= module_head);
5265
5266     /* if the is found in the list, then all is done and we may leave */
5267     if (found) return;
5268     /* otherwise we must add out module into the list */
5269     swig_module.next = module_head->next;
5270     module_head->next = &swig_module;
5271   }
5272
5273   /* When multiple interpeters are used, a module could have already been initialized in
5274        a different interpreter, but not yet have a pointer in this interpreter.
5275        In this case, we do not want to continue adding types... everything should be
5276        set up already */
5277   if (init == 0) return;
5278
5279   /* Now work on filling in swig_module.types */
5280 #ifdef SWIGRUNTIME_DEBUG
5281   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
5282 #endif
5283   for (i = 0; i < swig_module.size; ++i) {
5284     swig_type_info *type = 0;
5285     swig_type_info *ret;
5286     swig_cast_info *cast;
5287
5288 #ifdef SWIGRUNTIME_DEBUG
5289     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
5290 #endif
5291
5292     /* if there is another module already loaded */
5293     if (swig_module.next != &swig_module) {
5294       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
5295     }
5296     if (type) {
5297       /* Overwrite clientdata field */
5298 #ifdef SWIGRUNTIME_DEBUG
5299       printf("SWIG_InitializeModule: found type %s\n", type->name);
5300 #endif
5301       if (swig_module.type_initial[i]->clientdata) {
5302         type->clientdata = swig_module.type_initial[i]->clientdata;
5303 #ifdef SWIGRUNTIME_DEBUG
5304         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
5305 #endif
5306       }
5307     } else {
5308       type = swig_module.type_initial[i];
5309     }
5310
5311     /* Insert casting types */
5312     cast = swig_module.cast_initial[i];
5313     while (cast->type) {
5314       /* Don't need to add information already in the list */
5315       ret = 0;
5316 #ifdef SWIGRUNTIME_DEBUG
5317       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
5318 #endif
5319       if (swig_module.next != &swig_module) {
5320         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
5321 #ifdef SWIGRUNTIME_DEBUG
5322         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
5323 #endif
5324       }
5325       if (ret) {
5326         if (type == swig_module.type_initial[i]) {
5327 #ifdef SWIGRUNTIME_DEBUG
5328           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
5329 #endif
5330           cast->type = ret;
5331           ret = 0;
5332         } else {
5333           /* Check for casting already in the list */
5334           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
5335 #ifdef SWIGRUNTIME_DEBUG
5336           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
5337 #endif
5338           if (!ocast) ret = 0;
5339         }
5340       }
5341
5342       if (!ret) {
5343 #ifdef SWIGRUNTIME_DEBUG
5344         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
5345 #endif
5346         if (type->cast) {
5347           type->cast->prev = cast;
5348           cast->next = type->cast;
5349         }
5350         type->cast = cast;
5351       }
5352       cast++;
5353     }
5354     /* Set entry in modules->types array equal to the type */
5355     swig_module.types[i] = type;
5356   }
5357   swig_module.types[i] = 0;
5358
5359 #ifdef SWIGRUNTIME_DEBUG
5360   printf("**** SWIG_InitializeModule: Cast List ******\n");
5361   for (i = 0; i < swig_module.size; ++i) {
5362     int j = 0;
5363     swig_cast_info *cast = swig_module.cast_initial[i];
5364     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
5365     while (cast->type) {
5366       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
5367       cast++;
5368       ++j;
5369     }
5370     printf("---- Total casts: %d\n",j);
5371   }
5372   printf("**** SWIG_InitializeModule: Cast List ******\n");
5373 #endif
5374 }
5375
5376 /* This function will propagate the clientdata field of type to
5377 * any new swig_type_info structures that have been added into the list
5378 * of equivalent types.  It is like calling
5379 * SWIG_TypeClientData(type, clientdata) a second time.
5380 */
5381 SWIGRUNTIME void
5382 SWIG_PropagateClientData(void) {
5383   size_t i;
5384   swig_cast_info *equiv;
5385   static int init_run = 0;
5386
5387   if (init_run) return;
5388   init_run = 1;
5389
5390   for (i = 0; i < swig_module.size; i++) {
5391     if (swig_module.types[i]->clientdata) {
5392       equiv = swig_module.types[i]->cast;
5393       while (equiv) {
5394         if (!equiv->converter) {
5395           if (equiv->type && !equiv->type->clientdata)
5396           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
5397         }
5398         equiv = equiv->next;
5399       }
5400     }
5401   }
5402 }
5403
5404 #ifdef __cplusplus
5405 #if 0
5406 {
5407   /* c-mode */
5408 #endif
5409 }
5410 #endif
5411
5412
5413
5414 #ifdef __cplusplus
5415 extern "C"
5416 #endif
5417
5418 XS(SWIG_init) {
5419   dXSARGS;
5420   int i;
5421
5422   SWIG_InitializeModule(0);
5423
5424   /* Install commands */
5425   for (i = 0; swig_commands[i].name; i++) {
5426     newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
5427   }
5428
5429   /* Install variables */
5430   for (i = 0; swig_variables[i].name; i++) {
5431     SV *sv;
5432     sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
5433     if (swig_variables[i].type) {
5434       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
5435     } else {
5436       sv_setiv(sv,(IV) 0);
5437     }
5438     swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
5439   }
5440
5441   /* Install constant */
5442   for (i = 0; swig_constants[i].type; i++) {
5443     SV *sv;
5444     sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
5445     switch(swig_constants[i].type) {
5446     case SWIG_INT:
5447       sv_setiv(sv, (IV) swig_constants[i].lvalue);
5448       break;
5449     case SWIG_FLOAT:
5450       sv_setnv(sv, (double) swig_constants[i].dvalue);
5451       break;
5452     case SWIG_STRING:
5453       sv_setpv(sv, (char *) swig_constants[i].pvalue);
5454       break;
5455     case SWIG_POINTER:
5456       SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
5457       break;
5458     case SWIG_BINARY:
5459       SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
5460       break;
5461     default:
5462       break;
5463     }
5464     SvREADONLY_on(sv);
5465   }
5466
5467   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5468     SV *sv = get_sv((char*) SWIG_prefix "CNF_ORG", TRUE | 0x2 | GV_ADDMULTI);
5469     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_ORG)));
5470     SvREADONLY_on(sv);
5471   } while(0) /*@SWIG@*/;
5472   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5473     SV *sv = get_sv((char*) SWIG_prefix "CNF_CONF", TRUE | 0x2 | GV_ADDMULTI);
5474     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CONF)));
5475     SvREADONLY_on(sv);
5476   } while(0) /*@SWIG@*/;
5477   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5478     SV *sv = get_sv((char*) SWIG_prefix "CNF_AMDUMP_SERVER", TRUE | 0x2 | GV_ADDMULTI);
5479     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AMDUMP_SERVER)));
5480     SvREADONLY_on(sv);
5481   } while(0) /*@SWIG@*/;
5482   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5483     SV *sv = get_sv((char*) SWIG_prefix "CNF_INDEX_SERVER", TRUE | 0x2 | GV_ADDMULTI);
5484     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_INDEX_SERVER)));
5485     SvREADONLY_on(sv);
5486   } while(0) /*@SWIG@*/;
5487   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5488     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPE_SERVER", TRUE | 0x2 | GV_ADDMULTI);
5489     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPE_SERVER)));
5490     SvREADONLY_on(sv);
5491   } while(0) /*@SWIG@*/;
5492   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5493     SV *sv = get_sv((char*) SWIG_prefix "CNF_AUTH", TRUE | 0x2 | GV_ADDMULTI);
5494     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AUTH)));
5495     SvREADONLY_on(sv);
5496   } while(0) /*@SWIG@*/;
5497   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5498     SV *sv = get_sv((char*) SWIG_prefix "CNF_SSH_KEYS", TRUE | 0x2 | GV_ADDMULTI);
5499     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_SSH_KEYS)));
5500     SvREADONLY_on(sv);
5501   } while(0) /*@SWIG@*/;
5502   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5503     SV *sv = get_sv((char*) SWIG_prefix "CNF_AMANDAD_PATH", TRUE | 0x2 | GV_ADDMULTI);
5504     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AMANDAD_PATH)));
5505     SvREADONLY_on(sv);
5506   } while(0) /*@SWIG@*/;
5507   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5508     SV *sv = get_sv((char*) SWIG_prefix "CNF_CLIENT_USERNAME", TRUE | 0x2 | GV_ADDMULTI);
5509     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CLIENT_USERNAME)));
5510     SvREADONLY_on(sv);
5511   } while(0) /*@SWIG@*/;
5512   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5513     SV *sv = get_sv((char*) SWIG_prefix "CNF_CLIENT_PORT", TRUE | 0x2 | GV_ADDMULTI);
5514     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CLIENT_PORT)));
5515     SvREADONLY_on(sv);
5516   } while(0) /*@SWIG@*/;
5517   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5518     SV *sv = get_sv((char*) SWIG_prefix "CNF_GNUTAR_LIST_DIR", TRUE | 0x2 | GV_ADDMULTI);
5519     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_GNUTAR_LIST_DIR)));
5520     SvREADONLY_on(sv);
5521   } while(0) /*@SWIG@*/;
5522   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5523     SV *sv = get_sv((char*) SWIG_prefix "CNF_AMANDATES", TRUE | 0x2 | GV_ADDMULTI);
5524     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AMANDATES)));
5525     SvREADONLY_on(sv);
5526   } while(0) /*@SWIG@*/;
5527   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5528     SV *sv = get_sv((char*) SWIG_prefix "CNF_MAILER", TRUE | 0x2 | GV_ADDMULTI);
5529     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_MAILER)));
5530     SvREADONLY_on(sv);
5531   } while(0) /*@SWIG@*/;
5532   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5533     SV *sv = get_sv((char*) SWIG_prefix "CNF_MAILTO", TRUE | 0x2 | GV_ADDMULTI);
5534     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_MAILTO)));
5535     SvREADONLY_on(sv);
5536   } while(0) /*@SWIG@*/;
5537   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5538     SV *sv = get_sv((char*) SWIG_prefix "CNF_DUMPUSER", TRUE | 0x2 | GV_ADDMULTI);
5539     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DUMPUSER)));
5540     SvREADONLY_on(sv);
5541   } while(0) /*@SWIG@*/;
5542   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5543     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPEDEV", TRUE | 0x2 | GV_ADDMULTI);
5544     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPEDEV)));
5545     SvREADONLY_on(sv);
5546   } while(0) /*@SWIG@*/;
5547   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5548     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEVICE_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
5549     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEVICE_PROPERTY)));
5550     SvREADONLY_on(sv);
5551   } while(0) /*@SWIG@*/;
5552   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5553     SV *sv = get_sv((char*) SWIG_prefix "CNF_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
5554     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_PROPERTY)));
5555     SvREADONLY_on(sv);
5556   } while(0) /*@SWIG@*/;
5557   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5558     SV *sv = get_sv((char*) SWIG_prefix "CNF_CHANGERDEV", TRUE | 0x2 | GV_ADDMULTI);
5559     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CHANGERDEV)));
5560     SvREADONLY_on(sv);
5561   } while(0) /*@SWIG@*/;
5562   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5563     SV *sv = get_sv((char*) SWIG_prefix "CNF_CHANGERFILE", TRUE | 0x2 | GV_ADDMULTI);
5564     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CHANGERFILE)));
5565     SvREADONLY_on(sv);
5566   } while(0) /*@SWIG@*/;
5567   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5568     SV *sv = get_sv((char*) SWIG_prefix "CNF_LABELSTR", TRUE | 0x2 | GV_ADDMULTI);
5569     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_LABELSTR)));
5570     SvREADONLY_on(sv);
5571   } while(0) /*@SWIG@*/;
5572   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5573     SV *sv = get_sv((char*) SWIG_prefix "CNF_AUTOLABEL", TRUE | 0x2 | GV_ADDMULTI);
5574     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AUTOLABEL)));
5575     SvREADONLY_on(sv);
5576   } while(0) /*@SWIG@*/;
5577   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5578     SV *sv = get_sv((char*) SWIG_prefix "CNF_META_AUTOLABEL", TRUE | 0x2 | GV_ADDMULTI);
5579     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_META_AUTOLABEL)));
5580     SvREADONLY_on(sv);
5581   } while(0) /*@SWIG@*/;
5582   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5583     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPELIST", TRUE | 0x2 | GV_ADDMULTI);
5584     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPELIST)));
5585     SvREADONLY_on(sv);
5586   } while(0) /*@SWIG@*/;
5587   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5588     SV *sv = get_sv((char*) SWIG_prefix "CNF_DISKFILE", TRUE | 0x2 | GV_ADDMULTI);
5589     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DISKFILE)));
5590     SvREADONLY_on(sv);
5591   } while(0) /*@SWIG@*/;
5592   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5593     SV *sv = get_sv((char*) SWIG_prefix "CNF_INFOFILE", TRUE | 0x2 | GV_ADDMULTI);
5594     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_INFOFILE)));
5595     SvREADONLY_on(sv);
5596   } while(0) /*@SWIG@*/;
5597   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5598     SV *sv = get_sv((char*) SWIG_prefix "CNF_LOGDIR", TRUE | 0x2 | GV_ADDMULTI);
5599     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_LOGDIR)));
5600     SvREADONLY_on(sv);
5601   } while(0) /*@SWIG@*/;
5602   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5603     SV *sv = get_sv((char*) SWIG_prefix "CNF_INDEXDIR", TRUE | 0x2 | GV_ADDMULTI);
5604     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_INDEXDIR)));
5605     SvREADONLY_on(sv);
5606   } while(0) /*@SWIG@*/;
5607   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5608     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPETYPE", TRUE | 0x2 | GV_ADDMULTI);
5609     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPETYPE)));
5610     SvREADONLY_on(sv);
5611   } while(0) /*@SWIG@*/;
5612   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5613     SV *sv = get_sv((char*) SWIG_prefix "CNF_DUMPCYCLE", TRUE | 0x2 | GV_ADDMULTI);
5614     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DUMPCYCLE)));
5615     SvREADONLY_on(sv);
5616   } while(0) /*@SWIG@*/;
5617   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5618     SV *sv = get_sv((char*) SWIG_prefix "CNF_RUNSPERCYCLE", TRUE | 0x2 | GV_ADDMULTI);
5619     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_RUNSPERCYCLE)));
5620     SvREADONLY_on(sv);
5621   } while(0) /*@SWIG@*/;
5622   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5623     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPECYCLE", TRUE | 0x2 | GV_ADDMULTI);
5624     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPECYCLE)));
5625     SvREADONLY_on(sv);
5626   } while(0) /*@SWIG@*/;
5627   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5628     SV *sv = get_sv((char*) SWIG_prefix "CNF_NETUSAGE", TRUE | 0x2 | GV_ADDMULTI);
5629     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_NETUSAGE)));
5630     SvREADONLY_on(sv);
5631   } while(0) /*@SWIG@*/;
5632   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5633     SV *sv = get_sv((char*) SWIG_prefix "CNF_INPARALLEL", TRUE | 0x2 | GV_ADDMULTI);
5634     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_INPARALLEL)));
5635     SvREADONLY_on(sv);
5636   } while(0) /*@SWIG@*/;
5637   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5638     SV *sv = get_sv((char*) SWIG_prefix "CNF_DUMPORDER", TRUE | 0x2 | GV_ADDMULTI);
5639     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DUMPORDER)));
5640     SvREADONLY_on(sv);
5641   } while(0) /*@SWIG@*/;
5642   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5643     SV *sv = get_sv((char*) SWIG_prefix "CNF_BUMPPERCENT", TRUE | 0x2 | GV_ADDMULTI);
5644     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_BUMPPERCENT)));
5645     SvREADONLY_on(sv);
5646   } while(0) /*@SWIG@*/;
5647   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5648     SV *sv = get_sv((char*) SWIG_prefix "CNF_BUMPSIZE", TRUE | 0x2 | GV_ADDMULTI);
5649     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_BUMPSIZE)));
5650     SvREADONLY_on(sv);
5651   } while(0) /*@SWIG@*/;
5652   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5653     SV *sv = get_sv((char*) SWIG_prefix "CNF_BUMPMULT", TRUE | 0x2 | GV_ADDMULTI);
5654     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_BUMPMULT)));
5655     SvREADONLY_on(sv);
5656   } while(0) /*@SWIG@*/;
5657   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5658     SV *sv = get_sv((char*) SWIG_prefix "CNF_BUMPDAYS", TRUE | 0x2 | GV_ADDMULTI);
5659     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_BUMPDAYS)));
5660     SvREADONLY_on(sv);
5661   } while(0) /*@SWIG@*/;
5662   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5663     SV *sv = get_sv((char*) SWIG_prefix "CNF_TPCHANGER", TRUE | 0x2 | GV_ADDMULTI);
5664     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TPCHANGER)));
5665     SvREADONLY_on(sv);
5666   } while(0) /*@SWIG@*/;
5667   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5668     SV *sv = get_sv((char*) SWIG_prefix "CNF_RUNTAPES", TRUE | 0x2 | GV_ADDMULTI);
5669     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_RUNTAPES)));
5670     SvREADONLY_on(sv);
5671   } while(0) /*@SWIG@*/;
5672   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5673     SV *sv = get_sv((char*) SWIG_prefix "CNF_MAX_DLE_BY_VOLUME", TRUE | 0x2 | GV_ADDMULTI);
5674     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_MAX_DLE_BY_VOLUME)));
5675     SvREADONLY_on(sv);
5676   } while(0) /*@SWIG@*/;
5677   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5678     SV *sv = get_sv((char*) SWIG_prefix "CNF_MAXDUMPS", TRUE | 0x2 | GV_ADDMULTI);
5679     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_MAXDUMPS)));
5680     SvREADONLY_on(sv);
5681   } while(0) /*@SWIG@*/;
5682   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5683     SV *sv = get_sv((char*) SWIG_prefix "CNF_ETIMEOUT", TRUE | 0x2 | GV_ADDMULTI);
5684     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_ETIMEOUT)));
5685     SvREADONLY_on(sv);
5686   } while(0) /*@SWIG@*/;
5687   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5688     SV *sv = get_sv((char*) SWIG_prefix "CNF_DTIMEOUT", TRUE | 0x2 | GV_ADDMULTI);
5689     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DTIMEOUT)));
5690     SvREADONLY_on(sv);
5691   } while(0) /*@SWIG@*/;
5692   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5693     SV *sv = get_sv((char*) SWIG_prefix "CNF_CTIMEOUT", TRUE | 0x2 | GV_ADDMULTI);
5694     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CTIMEOUT)));
5695     SvREADONLY_on(sv);
5696   } while(0) /*@SWIG@*/;
5697   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5698     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEVICE_OUTPUT_BUFFER_SIZE", TRUE | 0x2 | GV_ADDMULTI);
5699     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEVICE_OUTPUT_BUFFER_SIZE)));
5700     SvREADONLY_on(sv);
5701   } while(0) /*@SWIG@*/;
5702   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5703     SV *sv = get_sv((char*) SWIG_prefix "CNF_PRINTER", TRUE | 0x2 | GV_ADDMULTI);
5704     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_PRINTER)));
5705     SvREADONLY_on(sv);
5706   } while(0) /*@SWIG@*/;
5707   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5708     SV *sv = get_sv((char*) SWIG_prefix "CNF_AUTOFLUSH", TRUE | 0x2 | GV_ADDMULTI);
5709     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AUTOFLUSH)));
5710     SvREADONLY_on(sv);
5711   } while(0) /*@SWIG@*/;
5712   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5713     SV *sv = get_sv((char*) SWIG_prefix "CNF_RESERVE", TRUE | 0x2 | GV_ADDMULTI);
5714     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_RESERVE)));
5715     SvREADONLY_on(sv);
5716   } while(0) /*@SWIG@*/;
5717   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5718     SV *sv = get_sv((char*) SWIG_prefix "CNF_MAXDUMPSIZE", TRUE | 0x2 | GV_ADDMULTI);
5719     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_MAXDUMPSIZE)));
5720     SvREADONLY_on(sv);
5721   } while(0) /*@SWIG@*/;
5722   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5723     SV *sv = get_sv((char*) SWIG_prefix "CNF_COLUMNSPEC", TRUE | 0x2 | GV_ADDMULTI);
5724     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_COLUMNSPEC)));
5725     SvREADONLY_on(sv);
5726   } while(0) /*@SWIG@*/;
5727   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5728     SV *sv = get_sv((char*) SWIG_prefix "CNF_AMRECOVER_DO_FSF", TRUE | 0x2 | GV_ADDMULTI);
5729     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AMRECOVER_DO_FSF)));
5730     SvREADONLY_on(sv);
5731   } while(0) /*@SWIG@*/;
5732   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5733     SV *sv = get_sv((char*) SWIG_prefix "CNF_AMRECOVER_CHECK_LABEL", TRUE | 0x2 | GV_ADDMULTI);
5734     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AMRECOVER_CHECK_LABEL)));
5735     SvREADONLY_on(sv);
5736   } while(0) /*@SWIG@*/;
5737   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5738     SV *sv = get_sv((char*) SWIG_prefix "CNF_AMRECOVER_CHANGER", TRUE | 0x2 | GV_ADDMULTI);
5739     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_AMRECOVER_CHANGER)));
5740     SvREADONLY_on(sv);
5741   } while(0) /*@SWIG@*/;
5742   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5743     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPERALGO", TRUE | 0x2 | GV_ADDMULTI);
5744     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPERALGO)));
5745     SvREADONLY_on(sv);
5746   } while(0) /*@SWIG@*/;
5747   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5748     SV *sv = get_sv((char*) SWIG_prefix "CNF_FLUSH_THRESHOLD_DUMPED", TRUE | 0x2 | GV_ADDMULTI);
5749     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_FLUSH_THRESHOLD_DUMPED)));
5750     SvREADONLY_on(sv);
5751   } while(0) /*@SWIG@*/;
5752   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5753     SV *sv = get_sv((char*) SWIG_prefix "CNF_FLUSH_THRESHOLD_SCHEDULED", TRUE | 0x2 | GV_ADDMULTI);
5754     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_FLUSH_THRESHOLD_SCHEDULED)));
5755     SvREADONLY_on(sv);
5756   } while(0) /*@SWIG@*/;
5757   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5758     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPERFLUSH", TRUE | 0x2 | GV_ADDMULTI);
5759     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPERFLUSH)));
5760     SvREADONLY_on(sv);
5761   } while(0) /*@SWIG@*/;
5762   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5763     SV *sv = get_sv((char*) SWIG_prefix "CNF_DISPLAYUNIT", TRUE | 0x2 | GV_ADDMULTI);
5764     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DISPLAYUNIT)));
5765     SvREADONLY_on(sv);
5766   } while(0) /*@SWIG@*/;
5767   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5768     SV *sv = get_sv((char*) SWIG_prefix "CNF_KRB5KEYTAB", TRUE | 0x2 | GV_ADDMULTI);
5769     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_KRB5KEYTAB)));
5770     SvREADONLY_on(sv);
5771   } while(0) /*@SWIG@*/;
5772   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5773     SV *sv = get_sv((char*) SWIG_prefix "CNF_KRB5PRINCIPAL", TRUE | 0x2 | GV_ADDMULTI);
5774     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_KRB5PRINCIPAL)));
5775     SvREADONLY_on(sv);
5776   } while(0) /*@SWIG@*/;
5777   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5778     SV *sv = get_sv((char*) SWIG_prefix "CNF_LABEL_NEW_TAPES", TRUE | 0x2 | GV_ADDMULTI);
5779     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_LABEL_NEW_TAPES)));
5780     SvREADONLY_on(sv);
5781   } while(0) /*@SWIG@*/;
5782   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5783     SV *sv = get_sv((char*) SWIG_prefix "CNF_USETIMESTAMPS", TRUE | 0x2 | GV_ADDMULTI);
5784     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_USETIMESTAMPS)));
5785     SvREADONLY_on(sv);
5786   } while(0) /*@SWIG@*/;
5787   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5788     SV *sv = get_sv((char*) SWIG_prefix "CNF_REP_TRIES", TRUE | 0x2 | GV_ADDMULTI);
5789     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_REP_TRIES)));
5790     SvREADONLY_on(sv);
5791   } while(0) /*@SWIG@*/;
5792   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5793     SV *sv = get_sv((char*) SWIG_prefix "CNF_CONNECT_TRIES", TRUE | 0x2 | GV_ADDMULTI);
5794     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_CONNECT_TRIES)));
5795     SvREADONLY_on(sv);
5796   } while(0) /*@SWIG@*/;
5797   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5798     SV *sv = get_sv((char*) SWIG_prefix "CNF_REQ_TRIES", TRUE | 0x2 | GV_ADDMULTI);
5799     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_REQ_TRIES)));
5800     SvREADONLY_on(sv);
5801   } while(0) /*@SWIG@*/;
5802   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5803     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_AMANDAD", TRUE | 0x2 | GV_ADDMULTI);
5804     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_AMANDAD)));
5805     SvREADONLY_on(sv);
5806   } while(0) /*@SWIG@*/;
5807   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5808     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_RECOVERY", TRUE | 0x2 | GV_ADDMULTI);
5809     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_RECOVERY)));
5810     SvREADONLY_on(sv);
5811   } while(0) /*@SWIG@*/;
5812   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5813     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_AMIDXTAPED", TRUE | 0x2 | GV_ADDMULTI);
5814     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_AMIDXTAPED)));
5815     SvREADONLY_on(sv);
5816   } while(0) /*@SWIG@*/;
5817   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5818     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_AMINDEXD", TRUE | 0x2 | GV_ADDMULTI);
5819     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_AMINDEXD)));
5820     SvREADONLY_on(sv);
5821   } while(0) /*@SWIG@*/;
5822   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5823     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_AMRECOVER", TRUE | 0x2 | GV_ADDMULTI);
5824     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_AMRECOVER)));
5825     SvREADONLY_on(sv);
5826   } while(0) /*@SWIG@*/;
5827   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5828     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_AUTH", TRUE | 0x2 | GV_ADDMULTI);
5829     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_AUTH)));
5830     SvREADONLY_on(sv);
5831   } while(0) /*@SWIG@*/;
5832   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5833     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_EVENT", TRUE | 0x2 | GV_ADDMULTI);
5834     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_EVENT)));
5835     SvREADONLY_on(sv);
5836   } while(0) /*@SWIG@*/;
5837   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5838     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_HOLDING", TRUE | 0x2 | GV_ADDMULTI);
5839     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_HOLDING)));
5840     SvREADONLY_on(sv);
5841   } while(0) /*@SWIG@*/;
5842   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5843     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_PROTOCOL", TRUE | 0x2 | GV_ADDMULTI);
5844     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_PROTOCOL)));
5845     SvREADONLY_on(sv);
5846   } while(0) /*@SWIG@*/;
5847   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5848     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_PLANNER", TRUE | 0x2 | GV_ADDMULTI);
5849     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_PLANNER)));
5850     SvREADONLY_on(sv);
5851   } while(0) /*@SWIG@*/;
5852   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5853     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_DRIVER", TRUE | 0x2 | GV_ADDMULTI);
5854     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_DRIVER)));
5855     SvREADONLY_on(sv);
5856   } while(0) /*@SWIG@*/;
5857   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5858     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_DUMPER", TRUE | 0x2 | GV_ADDMULTI);
5859     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_DUMPER)));
5860     SvREADONLY_on(sv);
5861   } while(0) /*@SWIG@*/;
5862   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5863     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_CHUNKER", TRUE | 0x2 | GV_ADDMULTI);
5864     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_CHUNKER)));
5865     SvREADONLY_on(sv);
5866   } while(0) /*@SWIG@*/;
5867   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5868     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_TAPER", TRUE | 0x2 | GV_ADDMULTI);
5869     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_TAPER)));
5870     SvREADONLY_on(sv);
5871   } while(0) /*@SWIG@*/;
5872   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5873     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_SELFCHECK", TRUE | 0x2 | GV_ADDMULTI);
5874     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_SELFCHECK)));
5875     SvREADONLY_on(sv);
5876   } while(0) /*@SWIG@*/;
5877   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5878     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_SENDSIZE", TRUE | 0x2 | GV_ADDMULTI);
5879     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_SENDSIZE)));
5880     SvREADONLY_on(sv);
5881   } while(0) /*@SWIG@*/;
5882   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5883     SV *sv = get_sv((char*) SWIG_prefix "CNF_DEBUG_SENDBACKUP", TRUE | 0x2 | GV_ADDMULTI);
5884     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_DEBUG_SENDBACKUP)));
5885     SvREADONLY_on(sv);
5886   } while(0) /*@SWIG@*/;
5887   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5888     SV *sv = get_sv((char*) SWIG_prefix "CNF_RESERVED_UDP_PORT", TRUE | 0x2 | GV_ADDMULTI);
5889     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_RESERVED_UDP_PORT)));
5890     SvREADONLY_on(sv);
5891   } while(0) /*@SWIG@*/;
5892   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5893     SV *sv = get_sv((char*) SWIG_prefix "CNF_RESERVED_TCP_PORT", TRUE | 0x2 | GV_ADDMULTI);
5894     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_RESERVED_TCP_PORT)));
5895     SvREADONLY_on(sv);
5896   } while(0) /*@SWIG@*/;
5897   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5898     SV *sv = get_sv((char*) SWIG_prefix "CNF_UNRESERVED_TCP_PORT", TRUE | 0x2 | GV_ADDMULTI);
5899     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_UNRESERVED_TCP_PORT)));
5900     SvREADONLY_on(sv);
5901   } while(0) /*@SWIG@*/;
5902   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5903     SV *sv = get_sv((char*) SWIG_prefix "CNF_HOLDINGDISK", TRUE | 0x2 | GV_ADDMULTI);
5904     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_HOLDINGDISK)));
5905     SvREADONLY_on(sv);
5906   } while(0) /*@SWIG@*/;
5907   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5908     SV *sv = get_sv((char*) SWIG_prefix "CNF_SEND_AMREPORT_ON", TRUE | 0x2 | GV_ADDMULTI);
5909     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_SEND_AMREPORT_ON)));
5910     SvREADONLY_on(sv);
5911   } while(0) /*@SWIG@*/;
5912   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5913     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPER_PARALLEL_WRITE", TRUE | 0x2 | GV_ADDMULTI);
5914     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPER_PARALLEL_WRITE)));
5915     SvREADONLY_on(sv);
5916   } while(0) /*@SWIG@*/;
5917   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5918     SV *sv = get_sv((char*) SWIG_prefix "CNF_RECOVERY_LIMIT", TRUE | 0x2 | GV_ADDMULTI);
5919     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_RECOVERY_LIMIT)));
5920     SvREADONLY_on(sv);
5921   } while(0) /*@SWIG@*/;
5922   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5923     SV *sv = get_sv((char*) SWIG_prefix "CNF_INTERACTIVITY", TRUE | 0x2 | GV_ADDMULTI);
5924     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_INTERACTIVITY)));
5925     SvREADONLY_on(sv);
5926   } while(0) /*@SWIG@*/;
5927   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5928     SV *sv = get_sv((char*) SWIG_prefix "CNF_TAPERSCAN", TRUE | 0x2 | GV_ADDMULTI);
5929     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_TAPERSCAN)));
5930     SvREADONLY_on(sv);
5931   } while(0) /*@SWIG@*/;
5932   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5933     SV *sv = get_sv((char*) SWIG_prefix "CNF_EJECT_VOLUME", TRUE | 0x2 | GV_ADDMULTI);
5934     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CNF_EJECT_VOLUME)));
5935     SvREADONLY_on(sv);
5936   } while(0) /*@SWIG@*/;
5937   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5938     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
5939     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_COMMENT)));
5940     SvREADONLY_on(sv);
5941   } while(0) /*@SWIG@*/;
5942   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5943     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_LBL_TEMPL", TRUE | 0x2 | GV_ADDMULTI);
5944     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_LBL_TEMPL)));
5945     SvREADONLY_on(sv);
5946   } while(0) /*@SWIG@*/;
5947   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5948     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_BLOCKSIZE", TRUE | 0x2 | GV_ADDMULTI);
5949     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_BLOCKSIZE)));
5950     SvREADONLY_on(sv);
5951   } while(0) /*@SWIG@*/;
5952   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5953     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_READBLOCKSIZE", TRUE | 0x2 | GV_ADDMULTI);
5954     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_READBLOCKSIZE)));
5955     SvREADONLY_on(sv);
5956   } while(0) /*@SWIG@*/;
5957   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5958     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_LENGTH", TRUE | 0x2 | GV_ADDMULTI);
5959     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_LENGTH)));
5960     SvREADONLY_on(sv);
5961   } while(0) /*@SWIG@*/;
5962   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5963     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_FILEMARK", TRUE | 0x2 | GV_ADDMULTI);
5964     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_FILEMARK)));
5965     SvREADONLY_on(sv);
5966   } while(0) /*@SWIG@*/;
5967   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5968     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_SPEED", TRUE | 0x2 | GV_ADDMULTI);
5969     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_SPEED)));
5970     SvREADONLY_on(sv);
5971   } while(0) /*@SWIG@*/;
5972   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5973     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_PART_SIZE", TRUE | 0x2 | GV_ADDMULTI);
5974     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_PART_SIZE)));
5975     SvREADONLY_on(sv);
5976   } while(0) /*@SWIG@*/;
5977   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5978     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_PART_CACHE_TYPE", TRUE | 0x2 | GV_ADDMULTI);
5979     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_PART_CACHE_TYPE)));
5980     SvREADONLY_on(sv);
5981   } while(0) /*@SWIG@*/;
5982   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5983     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_PART_CACHE_DIR", TRUE | 0x2 | GV_ADDMULTI);
5984     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_PART_CACHE_DIR)));
5985     SvREADONLY_on(sv);
5986   } while(0) /*@SWIG@*/;
5987   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5988     SV *sv = get_sv((char*) SWIG_prefix "TAPETYPE_PART_CACHE_MAX_SIZE", TRUE | 0x2 | GV_ADDMULTI);
5989     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPETYPE_PART_CACHE_MAX_SIZE)));
5990     SvREADONLY_on(sv);
5991   } while(0) /*@SWIG@*/;
5992   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5993     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
5994     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_COMMENT)));
5995     SvREADONLY_on(sv);
5996   } while(0) /*@SWIG@*/;
5997   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5998     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_PROGRAM", TRUE | 0x2 | GV_ADDMULTI);
5999     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_PROGRAM)));
6000     SvREADONLY_on(sv);
6001   } while(0) /*@SWIG@*/;
6002   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6003     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SRVCOMPPROG", TRUE | 0x2 | GV_ADDMULTI);
6004     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SRVCOMPPROG)));
6005     SvREADONLY_on(sv);
6006   } while(0) /*@SWIG@*/;
6007   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6008     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_CLNTCOMPPROG", TRUE | 0x2 | GV_ADDMULTI);
6009     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_CLNTCOMPPROG)));
6010     SvREADONLY_on(sv);
6011   } while(0) /*@SWIG@*/;
6012   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6013     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SRV_ENCRYPT", TRUE | 0x2 | GV_ADDMULTI);
6014     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SRV_ENCRYPT)));
6015     SvREADONLY_on(sv);
6016   } while(0) /*@SWIG@*/;
6017   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6018     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_CLNT_ENCRYPT", TRUE | 0x2 | GV_ADDMULTI);
6019     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_CLNT_ENCRYPT)));
6020     SvREADONLY_on(sv);
6021   } while(0) /*@SWIG@*/;
6022   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6023     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_AMANDAD_PATH", TRUE | 0x2 | GV_ADDMULTI);
6024     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_AMANDAD_PATH)));
6025     SvREADONLY_on(sv);
6026   } while(0) /*@SWIG@*/;
6027   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6028     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_CLIENT_USERNAME", TRUE | 0x2 | GV_ADDMULTI);
6029     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_CLIENT_USERNAME)));
6030     SvREADONLY_on(sv);
6031   } while(0) /*@SWIG@*/;
6032   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6033     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_CLIENT_PORT", TRUE | 0x2 | GV_ADDMULTI);
6034     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_CLIENT_PORT)));
6035     SvREADONLY_on(sv);
6036   } while(0) /*@SWIG@*/;
6037   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6038     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SSH_KEYS", TRUE | 0x2 | GV_ADDMULTI);
6039     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SSH_KEYS)));
6040     SvREADONLY_on(sv);
6041   } while(0) /*@SWIG@*/;
6042   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6043     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_AUTH", TRUE | 0x2 | GV_ADDMULTI);
6044     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_AUTH)));
6045     SvREADONLY_on(sv);
6046   } while(0) /*@SWIG@*/;
6047   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6048     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_EXCLUDE", TRUE | 0x2 | GV_ADDMULTI);
6049     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_EXCLUDE)));
6050     SvREADONLY_on(sv);
6051   } while(0) /*@SWIG@*/;
6052   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6053     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_INCLUDE", TRUE | 0x2 | GV_ADDMULTI);
6054     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_INCLUDE)));
6055     SvREADONLY_on(sv);
6056   } while(0) /*@SWIG@*/;
6057   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6058     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_PRIORITY", TRUE | 0x2 | GV_ADDMULTI);
6059     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_PRIORITY)));
6060     SvREADONLY_on(sv);
6061   } while(0) /*@SWIG@*/;
6062   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6063     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_DUMPCYCLE", TRUE | 0x2 | GV_ADDMULTI);
6064     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_DUMPCYCLE)));
6065     SvREADONLY_on(sv);
6066   } while(0) /*@SWIG@*/;
6067   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6068     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_MAXDUMPS", TRUE | 0x2 | GV_ADDMULTI);
6069     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_MAXDUMPS)));
6070     SvREADONLY_on(sv);
6071   } while(0) /*@SWIG@*/;
6072   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6073     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_MAXPROMOTEDAY", TRUE | 0x2 | GV_ADDMULTI);
6074     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_MAXPROMOTEDAY)));
6075     SvREADONLY_on(sv);
6076   } while(0) /*@SWIG@*/;
6077   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6078     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_BUMPPERCENT", TRUE | 0x2 | GV_ADDMULTI);
6079     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_BUMPPERCENT)));
6080     SvREADONLY_on(sv);
6081   } while(0) /*@SWIG@*/;
6082   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6083     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_BUMPSIZE", TRUE | 0x2 | GV_ADDMULTI);
6084     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_BUMPSIZE)));
6085     SvREADONLY_on(sv);
6086   } while(0) /*@SWIG@*/;
6087   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6088     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_BUMPDAYS", TRUE | 0x2 | GV_ADDMULTI);
6089     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_BUMPDAYS)));
6090     SvREADONLY_on(sv);
6091   } while(0) /*@SWIG@*/;
6092   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6093     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_BUMPMULT", TRUE | 0x2 | GV_ADDMULTI);
6094     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_BUMPMULT)));
6095     SvREADONLY_on(sv);
6096   } while(0) /*@SWIG@*/;
6097   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6098     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_STARTTIME", TRUE | 0x2 | GV_ADDMULTI);
6099     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_STARTTIME)));
6100     SvREADONLY_on(sv);
6101   } while(0) /*@SWIG@*/;
6102   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6103     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_STRATEGY", TRUE | 0x2 | GV_ADDMULTI);
6104     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_STRATEGY)));
6105     SvREADONLY_on(sv);
6106   } while(0) /*@SWIG@*/;
6107   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6108     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_ESTIMATELIST", TRUE | 0x2 | GV_ADDMULTI);
6109     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_ESTIMATELIST)));
6110     SvREADONLY_on(sv);
6111   } while(0) /*@SWIG@*/;
6112   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6113     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_COMPRESS", TRUE | 0x2 | GV_ADDMULTI);
6114     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_COMPRESS)));
6115     SvREADONLY_on(sv);
6116   } while(0) /*@SWIG@*/;
6117   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6118     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_ENCRYPT", TRUE | 0x2 | GV_ADDMULTI);
6119     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_ENCRYPT)));
6120     SvREADONLY_on(sv);
6121   } while(0) /*@SWIG@*/;
6122   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6123     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SRV_DECRYPT_OPT", TRUE | 0x2 | GV_ADDMULTI);
6124     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SRV_DECRYPT_OPT)));
6125     SvREADONLY_on(sv);
6126   } while(0) /*@SWIG@*/;
6127   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6128     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_CLNT_DECRYPT_OPT", TRUE | 0x2 | GV_ADDMULTI);
6129     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_CLNT_DECRYPT_OPT)));
6130     SvREADONLY_on(sv);
6131   } while(0) /*@SWIG@*/;
6132   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6133     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_COMPRATE", TRUE | 0x2 | GV_ADDMULTI);
6134     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_COMPRATE)));
6135     SvREADONLY_on(sv);
6136   } while(0) /*@SWIG@*/;
6137   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6138     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_TAPE_SPLITSIZE", TRUE | 0x2 | GV_ADDMULTI);
6139     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_TAPE_SPLITSIZE)));
6140     SvREADONLY_on(sv);
6141   } while(0) /*@SWIG@*/;
6142   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6143     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_FALLBACK_SPLITSIZE", TRUE | 0x2 | GV_ADDMULTI);
6144     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_FALLBACK_SPLITSIZE)));
6145     SvREADONLY_on(sv);
6146   } while(0) /*@SWIG@*/;
6147   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6148     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SPLIT_DISKBUFFER", TRUE | 0x2 | GV_ADDMULTI);
6149     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SPLIT_DISKBUFFER)));
6150     SvREADONLY_on(sv);
6151   } while(0) /*@SWIG@*/;
6152   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6153     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_RECORD", TRUE | 0x2 | GV_ADDMULTI);
6154     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_RECORD)));
6155     SvREADONLY_on(sv);
6156   } while(0) /*@SWIG@*/;
6157   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6158     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SKIP_INCR", TRUE | 0x2 | GV_ADDMULTI);
6159     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SKIP_INCR)));
6160     SvREADONLY_on(sv);
6161   } while(0) /*@SWIG@*/;
6162   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6163     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SKIP_FULL", TRUE | 0x2 | GV_ADDMULTI);
6164     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SKIP_FULL)));
6165     SvREADONLY_on(sv);
6166   } while(0) /*@SWIG@*/;
6167   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6168     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_HOLDINGDISK", TRUE | 0x2 | GV_ADDMULTI);
6169     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_HOLDINGDISK)));
6170     SvREADONLY_on(sv);
6171   } while(0) /*@SWIG@*/;
6172   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6173     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_KENCRYPT", TRUE | 0x2 | GV_ADDMULTI);
6174     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_KENCRYPT)));
6175     SvREADONLY_on(sv);
6176   } while(0) /*@SWIG@*/;
6177   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6178     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_IGNORE", TRUE | 0x2 | GV_ADDMULTI);
6179     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_IGNORE)));
6180     SvREADONLY_on(sv);
6181   } while(0) /*@SWIG@*/;
6182   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6183     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_INDEX", TRUE | 0x2 | GV_ADDMULTI);
6184     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_INDEX)));
6185     SvREADONLY_on(sv);
6186   } while(0) /*@SWIG@*/;
6187   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6188     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_APPLICATION", TRUE | 0x2 | GV_ADDMULTI);
6189     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_APPLICATION)));
6190     SvREADONLY_on(sv);
6191   } while(0) /*@SWIG@*/;
6192   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6193     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_SCRIPTLIST", TRUE | 0x2 | GV_ADDMULTI);
6194     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_SCRIPTLIST)));
6195     SvREADONLY_on(sv);
6196   } while(0) /*@SWIG@*/;
6197   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6198     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
6199     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_PROPERTY)));
6200     SvREADONLY_on(sv);
6201   } while(0) /*@SWIG@*/;
6202   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6203     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_DATA_PATH", TRUE | 0x2 | GV_ADDMULTI);
6204     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_DATA_PATH)));
6205     SvREADONLY_on(sv);
6206   } while(0) /*@SWIG@*/;
6207   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6208     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_ALLOW_SPLIT", TRUE | 0x2 | GV_ADDMULTI);
6209     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_ALLOW_SPLIT)));
6210     SvREADONLY_on(sv);
6211   } while(0) /*@SWIG@*/;
6212   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6213     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_RECOVERY_LIMIT", TRUE | 0x2 | GV_ADDMULTI);
6214     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_RECOVERY_LIMIT)));
6215     SvREADONLY_on(sv);
6216   } while(0) /*@SWIG@*/;
6217   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6218     SV *sv = get_sv((char*) SWIG_prefix "DUMPTYPE_DUMP_LIMIT", TRUE | 0x2 | GV_ADDMULTI);
6219     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DUMPTYPE_DUMP_LIMIT)));
6220     SvREADONLY_on(sv);
6221   } while(0) /*@SWIG@*/;
6222   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6223     SV *sv = get_sv((char*) SWIG_prefix "INTER_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
6224     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(INTER_COMMENT)));
6225     SvREADONLY_on(sv);
6226   } while(0) /*@SWIG@*/;
6227   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6228     SV *sv = get_sv((char*) SWIG_prefix "INTER_MAXUSAGE", TRUE | 0x2 | GV_ADDMULTI);
6229     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(INTER_MAXUSAGE)));
6230     SvREADONLY_on(sv);
6231   } while(0) /*@SWIG@*/;
6232   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6233     SV *sv = get_sv((char*) SWIG_prefix "HOLDING_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
6234     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLDING_COMMENT)));
6235     SvREADONLY_on(sv);
6236   } while(0) /*@SWIG@*/;
6237   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6238     SV *sv = get_sv((char*) SWIG_prefix "HOLDING_DISKDIR", TRUE | 0x2 | GV_ADDMULTI);
6239     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLDING_DISKDIR)));
6240     SvREADONLY_on(sv);
6241   } while(0) /*@SWIG@*/;
6242   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6243     SV *sv = get_sv((char*) SWIG_prefix "HOLDING_DISKSIZE", TRUE | 0x2 | GV_ADDMULTI);
6244     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLDING_DISKSIZE)));
6245     SvREADONLY_on(sv);
6246   } while(0) /*@SWIG@*/;
6247   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6248     SV *sv = get_sv((char*) SWIG_prefix "HOLDING_CHUNKSIZE", TRUE | 0x2 | GV_ADDMULTI);
6249     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLDING_CHUNKSIZE)));
6250     SvREADONLY_on(sv);
6251   } while(0) /*@SWIG@*/;
6252   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6253     SV *sv = get_sv((char*) SWIG_prefix "APPLICATION_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
6254     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(APPLICATION_COMMENT)));
6255     SvREADONLY_on(sv);
6256   } while(0) /*@SWIG@*/;
6257   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6258     SV *sv = get_sv((char*) SWIG_prefix "APPLICATION_PLUGIN", TRUE | 0x2 | GV_ADDMULTI);
6259     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(APPLICATION_PLUGIN)));
6260     SvREADONLY_on(sv);
6261   } while(0) /*@SWIG@*/;
6262   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6263     SV *sv = get_sv((char*) SWIG_prefix "APPLICATION_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
6264     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(APPLICATION_PROPERTY)));
6265     SvREADONLY_on(sv);
6266   } while(0) /*@SWIG@*/;
6267   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6268     SV *sv = get_sv((char*) SWIG_prefix "APPLICATION_CLIENT_NAME", TRUE | 0x2 | GV_ADDMULTI);
6269     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(APPLICATION_CLIENT_NAME)));
6270     SvREADONLY_on(sv);
6271   } while(0) /*@SWIG@*/;
6272   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6273     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
6274     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_COMMENT)));
6275     SvREADONLY_on(sv);
6276   } while(0) /*@SWIG@*/;
6277   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6278     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_PLUGIN", TRUE | 0x2 | GV_ADDMULTI);
6279     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_PLUGIN)));
6280     SvREADONLY_on(sv);
6281   } while(0) /*@SWIG@*/;
6282   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6283     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
6284     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_PROPERTY)));
6285     SvREADONLY_on(sv);
6286   } while(0) /*@SWIG@*/;
6287   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6288     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_EXECUTE_ON", TRUE | 0x2 | GV_ADDMULTI);
6289     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_EXECUTE_ON)));
6290     SvREADONLY_on(sv);
6291   } while(0) /*@SWIG@*/;
6292   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6293     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_EXECUTE_WHERE", TRUE | 0x2 | GV_ADDMULTI);
6294     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_EXECUTE_WHERE)));
6295     SvREADONLY_on(sv);
6296   } while(0) /*@SWIG@*/;
6297   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6298     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_ORDER", TRUE | 0x2 | GV_ADDMULTI);
6299     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_ORDER)));
6300     SvREADONLY_on(sv);
6301   } while(0) /*@SWIG@*/;
6302   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6303     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_SINGLE_EXECUTION", TRUE | 0x2 | GV_ADDMULTI);
6304     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_SINGLE_EXECUTION)));
6305     SvREADONLY_on(sv);
6306   } while(0) /*@SWIG@*/;
6307   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6308     SV *sv = get_sv((char*) SWIG_prefix "PP_SCRIPT_CLIENT_NAME", TRUE | 0x2 | GV_ADDMULTI);
6309     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PP_SCRIPT_CLIENT_NAME)));
6310     SvREADONLY_on(sv);
6311   } while(0) /*@SWIG@*/;
6312   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6313     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_CONFIG_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
6314     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_CONFIG_COMMENT)));
6315     SvREADONLY_on(sv);
6316   } while(0) /*@SWIG@*/;
6317   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6318     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_CONFIG_TAPEDEV", TRUE | 0x2 | GV_ADDMULTI);
6319     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_CONFIG_TAPEDEV)));
6320     SvREADONLY_on(sv);
6321   } while(0) /*@SWIG@*/;
6322   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6323     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_CONFIG_DEVICE_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
6324     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_CONFIG_DEVICE_PROPERTY)));
6325     SvREADONLY_on(sv);
6326   } while(0) /*@SWIG@*/;
6327   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6328     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
6329     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_COMMENT)));
6330     SvREADONLY_on(sv);
6331   } while(0) /*@SWIG@*/;
6332   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6333     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_TAPEDEV", TRUE | 0x2 | GV_ADDMULTI);
6334     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_TAPEDEV)));
6335     SvREADONLY_on(sv);
6336   } while(0) /*@SWIG@*/;
6337   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6338     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_TPCHANGER", TRUE | 0x2 | GV_ADDMULTI);
6339     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_TPCHANGER)));
6340     SvREADONLY_on(sv);
6341   } while(0) /*@SWIG@*/;
6342   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6343     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_CHANGERDEV", TRUE | 0x2 | GV_ADDMULTI);
6344     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_CHANGERDEV)));
6345     SvREADONLY_on(sv);
6346   } while(0) /*@SWIG@*/;
6347   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6348     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_CHANGERFILE", TRUE | 0x2 | GV_ADDMULTI);
6349     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_CHANGERFILE)));
6350     SvREADONLY_on(sv);
6351   } while(0) /*@SWIG@*/;
6352   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6353     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
6354     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_PROPERTY)));
6355     SvREADONLY_on(sv);
6356   } while(0) /*@SWIG@*/;
6357   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6358     SV *sv = get_sv((char*) SWIG_prefix "CHANGER_CONFIG_DEVICE_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
6359     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CHANGER_CONFIG_DEVICE_PROPERTY)));
6360     SvREADONLY_on(sv);
6361   } while(0) /*@SWIG@*/;
6362   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6363     SV *sv = get_sv((char*) SWIG_prefix "INTERACTIVITY_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
6364     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(INTERACTIVITY_COMMENT)));
6365     SvREADONLY_on(sv);
6366   } while(0) /*@SWIG@*/;
6367   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6368     SV *sv = get_sv((char*) SWIG_prefix "INTERACTIVITY_PLUGIN", TRUE | 0x2 | GV_ADDMULTI);
6369     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(INTERACTIVITY_PLUGIN)));
6370     SvREADONLY_on(sv);
6371   } while(0) /*@SWIG@*/;
6372   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6373     SV *sv = get_sv((char*) SWIG_prefix "INTERACTIVITY_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
6374     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(INTERACTIVITY_PROPERTY)));
6375     SvREADONLY_on(sv);
6376   } while(0) /*@SWIG@*/;
6377   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6378     SV *sv = get_sv((char*) SWIG_prefix "TAPERSCAN_COMMENT", TRUE | 0x2 | GV_ADDMULTI);
6379     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPERSCAN_COMMENT)));
6380     SvREADONLY_on(sv);
6381   } while(0) /*@SWIG@*/;
6382   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6383     SV *sv = get_sv((char*) SWIG_prefix "TAPERSCAN_PLUGIN", TRUE | 0x2 | GV_ADDMULTI);
6384     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPERSCAN_PLUGIN)));
6385     SvREADONLY_on(sv);
6386   } while(0) /*@SWIG@*/;
6387   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6388     SV *sv = get_sv((char*) SWIG_prefix "TAPERSCAN_PROPERTY", TRUE | 0x2 | GV_ADDMULTI);
6389     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(TAPERSCAN_PROPERTY)));
6390     SvREADONLY_on(sv);
6391   } while(0) /*@SWIG@*/;
6392   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6393     SV *sv = get_sv((char*) SWIG_prefix "HOLD_NEVER", TRUE | 0x2 | GV_ADDMULTI);
6394     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLD_NEVER)));
6395     SvREADONLY_on(sv);
6396   } while(0) /*@SWIG@*/;
6397   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6398     SV *sv = get_sv((char*) SWIG_prefix "HOLD_AUTO", TRUE | 0x2 | GV_ADDMULTI);
6399     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLD_AUTO)));
6400     SvREADONLY_on(sv);
6401   } while(0) /*@SWIG@*/;
6402   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6403     SV *sv = get_sv((char*) SWIG_prefix "HOLD_REQUIRED", TRUE | 0x2 | GV_ADDMULTI);
6404     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(HOLD_REQUIRED)));
6405     SvREADONLY_on(sv);
6406   } while(0) /*@SWIG@*/;
6407   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6408     SV *sv = get_sv((char*) SWIG_prefix "COMP_NONE", TRUE | 0x2 | GV_ADDMULTI);
6409     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_NONE)));
6410     SvREADONLY_on(sv);
6411   } while(0) /*@SWIG@*/;
6412   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6413     SV *sv = get_sv((char*) SWIG_prefix "COMP_FAST", TRUE | 0x2 | GV_ADDMULTI);
6414     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_FAST)));
6415     SvREADONLY_on(sv);
6416   } while(0) /*@SWIG@*/;
6417   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6418     SV *sv = get_sv((char*) SWIG_prefix "COMP_BEST", TRUE | 0x2 | GV_ADDMULTI);
6419     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_BEST)));
6420     SvREADONLY_on(sv);
6421   } while(0) /*@SWIG@*/;
6422   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6423     SV *sv = get_sv((char*) SWIG_prefix "COMP_CUST", TRUE | 0x2 | GV_ADDMULTI);
6424     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_CUST)));
6425     SvREADONLY_on(sv);
6426   } while(0) /*@SWIG@*/;
6427   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6428     SV *sv = get_sv((char*) SWIG_prefix "COMP_SERVER_FAST", TRUE | 0x2 | GV_ADDMULTI);
6429     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_SERVER_FAST)));
6430     SvREADONLY_on(sv);
6431   } while(0) /*@SWIG@*/;
6432   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6433     SV *sv = get_sv((char*) SWIG_prefix "COMP_SERVER_BEST", TRUE | 0x2 | GV_ADDMULTI);
6434     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_SERVER_BEST)));
6435     SvREADONLY_on(sv);
6436   } while(0) /*@SWIG@*/;
6437   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6438     SV *sv = get_sv((char*) SWIG_prefix "COMP_SERVER_CUST", TRUE | 0x2 | GV_ADDMULTI);
6439     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(COMP_SERVER_CUST)));
6440     SvREADONLY_on(sv);
6441   } while(0) /*@SWIG@*/;
6442   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6443     SV *sv = get_sv((char*) SWIG_prefix "ENCRYPT_NONE", TRUE | 0x2 | GV_ADDMULTI);
6444     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ENCRYPT_NONE)));
6445     SvREADONLY_on(sv);
6446   } while(0) /*@SWIG@*/;
6447   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6448     SV *sv = get_sv((char*) SWIG_prefix "ENCRYPT_CUST", TRUE | 0x2 | GV_ADDMULTI);
6449     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ENCRYPT_CUST)));
6450     SvREADONLY_on(sv);
6451   } while(0) /*@SWIG@*/;
6452   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6453     SV *sv = get_sv((char*) SWIG_prefix "ENCRYPT_SERV_CUST", TRUE | 0x2 | GV_ADDMULTI);
6454     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ENCRYPT_SERV_CUST)));
6455     SvREADONLY_on(sv);
6456   } while(0) /*@SWIG@*/;
6457   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6458     SV *sv = get_sv((char*) SWIG_prefix "DS_SKIP", TRUE | 0x2 | GV_ADDMULTI);
6459     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_SKIP)));
6460     SvREADONLY_on(sv);
6461   } while(0) /*@SWIG@*/;
6462   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6463     SV *sv = get_sv((char*) SWIG_prefix "DS_STANDARD", TRUE | 0x2 | GV_ADDMULTI);
6464     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_STANDARD)));
6465     SvREADONLY_on(sv);
6466   } while(0) /*@SWIG@*/;
6467   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6468     SV *sv = get_sv((char*) SWIG_prefix "DS_NOFULL", TRUE | 0x2 | GV_ADDMULTI);
6469     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_NOFULL)));
6470     SvREADONLY_on(sv);
6471   } while(0) /*@SWIG@*/;
6472   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6473     SV *sv = get_sv((char*) SWIG_prefix "DS_NOINC", TRUE | 0x2 | GV_ADDMULTI);
6474     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_NOINC)));
6475     SvREADONLY_on(sv);
6476   } while(0) /*@SWIG@*/;
6477   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6478     SV *sv = get_sv((char*) SWIG_prefix "DS_4", TRUE | 0x2 | GV_ADDMULTI);
6479     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_4)));
6480     SvREADONLY_on(sv);
6481   } while(0) /*@SWIG@*/;
6482   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6483     SV *sv = get_sv((char*) SWIG_prefix "DS_5", TRUE | 0x2 | GV_ADDMULTI);
6484     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_5)));
6485     SvREADONLY_on(sv);
6486   } while(0) /*@SWIG@*/;
6487   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6488     SV *sv = get_sv((char*) SWIG_prefix "DS_HANOI", TRUE | 0x2 | GV_ADDMULTI);
6489     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_HANOI)));
6490     SvREADONLY_on(sv);
6491   } while(0) /*@SWIG@*/;
6492   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6493     SV *sv = get_sv((char*) SWIG_prefix "DS_INCRONLY", TRUE | 0x2 | GV_ADDMULTI);
6494     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DS_INCRONLY)));
6495     SvREADONLY_on(sv);
6496   } while(0) /*@SWIG@*/;
6497   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6498     SV *sv = get_sv((char*) SWIG_prefix "ES_CLIENT", TRUE | 0x2 | GV_ADDMULTI);
6499     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ES_CLIENT)));
6500     SvREADONLY_on(sv);
6501   } while(0) /*@SWIG@*/;
6502   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6503     SV *sv = get_sv((char*) SWIG_prefix "ES_SERVER", TRUE | 0x2 | GV_ADDMULTI);
6504     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ES_SERVER)));
6505     SvREADONLY_on(sv);
6506   } while(0) /*@SWIG@*/;
6507   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6508     SV *sv = get_sv((char*) SWIG_prefix "ES_CALCSIZE", TRUE | 0x2 | GV_ADDMULTI);
6509     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ES_CALCSIZE)));
6510     SvREADONLY_on(sv);
6511   } while(0) /*@SWIG@*/;
6512   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6513     SV *sv = get_sv((char*) SWIG_prefix "AL_OTHER_CONFIG", TRUE | 0x2 | GV_ADDMULTI);
6514     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(AL_OTHER_CONFIG)));
6515     SvREADONLY_on(sv);
6516   } while(0) /*@SWIG@*/;
6517   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6518     SV *sv = get_sv((char*) SWIG_prefix "AL_NON_AMANDA", TRUE | 0x2 | GV_ADDMULTI);
6519     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(AL_NON_AMANDA)));
6520     SvREADONLY_on(sv);
6521   } while(0) /*@SWIG@*/;
6522   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6523     SV *sv = get_sv((char*) SWIG_prefix "AL_VOLUME_ERROR", TRUE | 0x2 | GV_ADDMULTI);
6524     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(AL_VOLUME_ERROR)));
6525     SvREADONLY_on(sv);
6526   } while(0) /*@SWIG@*/;
6527   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6528     SV *sv = get_sv((char*) SWIG_prefix "AL_EMPTY", TRUE | 0x2 | GV_ADDMULTI);
6529     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(AL_EMPTY)));
6530     SvREADONLY_on(sv);
6531   } while(0) /*@SWIG@*/;
6532   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6533     SV *sv = get_sv((char*) SWIG_prefix "ALGO_FIRST", TRUE | 0x2 | GV_ADDMULTI);
6534     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_FIRST)));
6535     SvREADONLY_on(sv);
6536   } while(0) /*@SWIG@*/;
6537   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6538     SV *sv = get_sv((char*) SWIG_prefix "ALGO_FIRSTFIT", TRUE | 0x2 | GV_ADDMULTI);
6539     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_FIRSTFIT)));
6540     SvREADONLY_on(sv);
6541   } while(0) /*@SWIG@*/;
6542   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6543     SV *sv = get_sv((char*) SWIG_prefix "ALGO_LARGEST", TRUE | 0x2 | GV_ADDMULTI);
6544     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_LARGEST)));
6545     SvREADONLY_on(sv);
6546   } while(0) /*@SWIG@*/;
6547   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6548     SV *sv = get_sv((char*) SWIG_prefix "ALGO_LARGESTFIT", TRUE | 0x2 | GV_ADDMULTI);
6549     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_LARGESTFIT)));
6550     SvREADONLY_on(sv);
6551   } while(0) /*@SWIG@*/;
6552   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6553     SV *sv = get_sv((char*) SWIG_prefix "ALGO_SMALLEST", TRUE | 0x2 | GV_ADDMULTI);
6554     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_SMALLEST)));
6555     SvREADONLY_on(sv);
6556   } while(0) /*@SWIG@*/;
6557   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6558     SV *sv = get_sv((char*) SWIG_prefix "ALGO_LAST", TRUE | 0x2 | GV_ADDMULTI);
6559     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ALGO_LAST)));
6560     SvREADONLY_on(sv);
6561   } while(0) /*@SWIG@*/;
6562   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6563     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_AMCHECK", TRUE | 0x2 | GV_ADDMULTI);
6564     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_AMCHECK)));
6565     SvREADONLY_on(sv);
6566   } while(0) /*@SWIG@*/;
6567   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6568     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_DLE_AMCHECK", TRUE | 0x2 | GV_ADDMULTI);
6569     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_DLE_AMCHECK)));
6570     SvREADONLY_on(sv);
6571   } while(0) /*@SWIG@*/;
6572   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6573     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_HOST_AMCHECK", TRUE | 0x2 | GV_ADDMULTI);
6574     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_HOST_AMCHECK)));
6575     SvREADONLY_on(sv);
6576   } while(0) /*@SWIG@*/;
6577   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6578     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_AMCHECK", TRUE | 0x2 | GV_ADDMULTI);
6579     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_AMCHECK)));
6580     SvREADONLY_on(sv);
6581   } while(0) /*@SWIG@*/;
6582   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6583     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_DLE_AMCHECK", TRUE | 0x2 | GV_ADDMULTI);
6584     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_DLE_AMCHECK)));
6585     SvREADONLY_on(sv);
6586   } while(0) /*@SWIG@*/;
6587   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6588     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_HOST_AMCHECK", TRUE | 0x2 | GV_ADDMULTI);
6589     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_HOST_AMCHECK)));
6590     SvREADONLY_on(sv);
6591   } while(0) /*@SWIG@*/;
6592   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6593     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_ESTIMATE", TRUE | 0x2 | GV_ADDMULTI);
6594     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_ESTIMATE)));
6595     SvREADONLY_on(sv);
6596   } while(0) /*@SWIG@*/;
6597   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6598     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_DLE_ESTIMATE", TRUE | 0x2 | GV_ADDMULTI);
6599     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_DLE_ESTIMATE)));
6600     SvREADONLY_on(sv);
6601   } while(0) /*@SWIG@*/;
6602   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6603     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_HOST_ESTIMATE", TRUE | 0x2 | GV_ADDMULTI);
6604     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_HOST_ESTIMATE)));
6605     SvREADONLY_on(sv);
6606   } while(0) /*@SWIG@*/;
6607   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6608     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_ESTIMATE", TRUE | 0x2 | GV_ADDMULTI);
6609     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_ESTIMATE)));
6610     SvREADONLY_on(sv);
6611   } while(0) /*@SWIG@*/;
6612   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6613     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_DLE_ESTIMATE", TRUE | 0x2 | GV_ADDMULTI);
6614     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_DLE_ESTIMATE)));
6615     SvREADONLY_on(sv);
6616   } while(0) /*@SWIG@*/;
6617   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6618     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_HOST_ESTIMATE", TRUE | 0x2 | GV_ADDMULTI);
6619     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_HOST_ESTIMATE)));
6620     SvREADONLY_on(sv);
6621   } while(0) /*@SWIG@*/;
6622   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6623     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_BACKUP", TRUE | 0x2 | GV_ADDMULTI);
6624     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_BACKUP)));
6625     SvREADONLY_on(sv);
6626   } while(0) /*@SWIG@*/;
6627   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6628     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_DLE_BACKUP", TRUE | 0x2 | GV_ADDMULTI);
6629     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_DLE_BACKUP)));
6630     SvREADONLY_on(sv);
6631   } while(0) /*@SWIG@*/;
6632   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6633     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_PRE_HOST_BACKUP", TRUE | 0x2 | GV_ADDMULTI);
6634     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_PRE_HOST_BACKUP)));
6635     SvREADONLY_on(sv);
6636   } while(0) /*@SWIG@*/;
6637   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6638     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_BACKUP", TRUE | 0x2 | GV_ADDMULTI);
6639     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_BACKUP)));
6640     SvREADONLY_on(sv);
6641   } while(0) /*@SWIG@*/;
6642   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6643     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_DLE_BACKUP", TRUE | 0x2 | GV_ADDMULTI);
6644     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_DLE_BACKUP)));
6645     SvREADONLY_on(sv);
6646   } while(0) /*@SWIG@*/;
6647   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6648     SV *sv = get_sv((char*) SWIG_prefix "EXECUTE_ON_POST_HOST_BACKUP", TRUE | 0x2 | GV_ADDMULTI);
6649     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(EXECUTE_ON_POST_HOST_BACKUP)));
6650     SvREADONLY_on(sv);
6651   } while(0) /*@SWIG@*/;
6652   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6653     SV *sv = get_sv((char*) SWIG_prefix "SEND_AMREPORT_ALL", TRUE | 0x2 | GV_ADDMULTI);
6654     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SEND_AMREPORT_ALL)));
6655     SvREADONLY_on(sv);
6656   } while(0) /*@SWIG@*/;
6657   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6658     SV *sv = get_sv((char*) SWIG_prefix "SEND_AMREPORT_STRANGE", TRUE | 0x2 | GV_ADDMULTI);
6659     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SEND_AMREPORT_STRANGE)));
6660     SvREADONLY_on(sv);
6661   } while(0) /*@SWIG@*/;
6662   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6663     SV *sv = get_sv((char*) SWIG_prefix "SEND_AMREPORT_ERROR", TRUE | 0x2 | GV_ADDMULTI);
6664     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SEND_AMREPORT_ERROR)));
6665     SvREADONLY_on(sv);
6666   } while(0) /*@SWIG@*/;
6667   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6668     SV *sv = get_sv((char*) SWIG_prefix "SEND_AMREPORT_NEVER", TRUE | 0x2 | GV_ADDMULTI);
6669     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SEND_AMREPORT_NEVER)));
6670     SvREADONLY_on(sv);
6671   } while(0) /*@SWIG@*/;
6672   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6673     SV *sv = get_sv((char*) SWIG_prefix "DATA_PATH_AMANDA", TRUE | 0x2 | GV_ADDMULTI);
6674     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DATA_PATH_AMANDA)));
6675     SvREADONLY_on(sv);
6676   } while(0) /*@SWIG@*/;
6677   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6678     SV *sv = get_sv((char*) SWIG_prefix "DATA_PATH_DIRECTTCP", TRUE | 0x2 | GV_ADDMULTI);
6679     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DATA_PATH_DIRECTTCP)));
6680     SvREADONLY_on(sv);
6681   } while(0) /*@SWIG@*/;
6682   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6683     SV *sv = get_sv((char*) SWIG_prefix "PART_CACHE_TYPE_NONE", TRUE | 0x2 | GV_ADDMULTI);
6684     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PART_CACHE_TYPE_NONE)));
6685     SvREADONLY_on(sv);
6686   } while(0) /*@SWIG@*/;
6687   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6688     SV *sv = get_sv((char*) SWIG_prefix "PART_CACHE_TYPE_DISK", TRUE | 0x2 | GV_ADDMULTI);
6689     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PART_CACHE_TYPE_DISK)));
6690     SvREADONLY_on(sv);
6691   } while(0) /*@SWIG@*/;
6692   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6693     SV *sv = get_sv((char*) SWIG_prefix "PART_CACHE_TYPE_MEMORY", TRUE | 0x2 | GV_ADDMULTI);
6694     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PART_CACHE_TYPE_MEMORY)));
6695     SvREADONLY_on(sv);
6696   } while(0) /*@SWIG@*/;
6697   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6698     SV *sv = get_sv((char*) SWIG_prefix "CFGERR_OK", TRUE | 0x2 | GV_ADDMULTI);
6699     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CFGERR_OK)));
6700     SvREADONLY_on(sv);
6701   } while(0) /*@SWIG@*/;
6702   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6703     SV *sv = get_sv((char*) SWIG_prefix "CFGERR_WARNINGS", TRUE | 0x2 | GV_ADDMULTI);
6704     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CFGERR_WARNINGS)));
6705     SvREADONLY_on(sv);
6706   } while(0) /*@SWIG@*/;
6707   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6708     SV *sv = get_sv((char*) SWIG_prefix "CFGERR_ERRORS", TRUE | 0x2 | GV_ADDMULTI);
6709     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CFGERR_ERRORS)));
6710     SvREADONLY_on(sv);
6711   } while(0) /*@SWIG@*/;
6712   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6713     SV *sv = get_sv((char*) SWIG_prefix "CONFIG_INIT_EXPLICIT_NAME", TRUE | 0x2 | GV_ADDMULTI);
6714     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONFIG_INIT_EXPLICIT_NAME)));
6715     SvREADONLY_on(sv);
6716   } while(0) /*@SWIG@*/;
6717   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6718     SV *sv = get_sv((char*) SWIG_prefix "CONFIG_INIT_USE_CWD", TRUE | 0x2 | GV_ADDMULTI);
6719     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONFIG_INIT_USE_CWD)));
6720     SvREADONLY_on(sv);
6721   } while(0) /*@SWIG@*/;
6722   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6723     SV *sv = get_sv((char*) SWIG_prefix "CONFIG_INIT_CLIENT", TRUE | 0x2 | GV_ADDMULTI);
6724     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONFIG_INIT_CLIENT)));
6725     SvREADONLY_on(sv);
6726   } while(0) /*@SWIG@*/;
6727   /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
6728     SV *sv = get_sv((char*) SWIG_prefix "CONFIG_INIT_OVERLAY", TRUE | 0x2 | GV_ADDMULTI);
6729     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONFIG_INIT_OVERLAY)));
6730     SvREADONLY_on(sv);
6731   } while(0) /*@SWIG@*/;
6732   ST(0) = &PL_sv_yes;
6733   XSRETURN(1);
6734 }
6735