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

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