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

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