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