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