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

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.39
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #include "../config/config.h"
  12
  13
  14 #define SWIGPERL
  15 #define SWIG_CASTRANK_MODE
  16
  17 /* -----------------------------------------------------------------------------
  18  *  This section contains generic SWIG labels for method/variable
  19  *  declarations/attributes, and other compiler dependent labels.
  20  * ----------------------------------------------------------------------------- */
  21
  22 /* template workaround for compilers that cannot correctly implement the C++ standard */
  23 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  24 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  25 #  define SWIGTEMPLATEDISAMBIGUATOR template
  26 # elif defined(__HP_aCC)
  27 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  28 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  29 #  define SWIGTEMPLATEDISAMBIGUATOR template
  30 # else
  31 #  define SWIGTEMPLATEDISAMBIGUATOR
  32 # endif
  33 #endif
  34
  35 /* inline attribute */
  36 #ifndef SWIGINLINE
  37 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  38 #   define SWIGINLINE inline
  39 # else
  40 #   define SWIGINLINE
  41 # endif
  42 #endif
  43
  44 /* attribute recognised by some compilers to avoid 'unused' warnings */
  45 #ifndef SWIGUNUSED
  46 # if defined(__GNUC__)
  47 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  48 #     define SWIGUNUSED __attribute__ ((__unused__))
  49 #   else
  50 #     define SWIGUNUSED
  51 #   endif
  52 # elif defined(__ICC)
  53 #   define SWIGUNUSED __attribute__ ((__unused__))
  54 # else
  55 #   define SWIGUNUSED
  56 # endif
  57 #endif
  58
  59 #ifndef SWIG_MSC_UNSUPPRESS_4505
  60 # if defined(_MSC_VER)
  61 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  62 # endif
  63 #endif
  64
  65 #ifndef SWIGUNUSEDPARM
  66 # ifdef __cplusplus
  67 #   define SWIGUNUSEDPARM(p)
  68 # else
  69 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  70 # endif
  71 #endif
  72
  73 /* internal SWIG method */
  74 #ifndef SWIGINTERN
  75 # define SWIGINTERN static SWIGUNUSED
  76 #endif
  77
  78 /* internal inline SWIG method */
  79 #ifndef SWIGINTERNINLINE
  80 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  81 #endif
  82
  83 /* exporting methods */
  84 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  85 #  ifndef GCC_HASCLASSVISIBILITY
  86 #    define GCC_HASCLASSVISIBILITY
  87 #  endif
  88 #endif
  89
  90 #ifndef SWIGEXPORT
  91 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  92 #   if defined(STATIC_LINKED)
  93 #     define SWIGEXPORT
  94 #   else
  95 #     define SWIGEXPORT __declspec(dllexport)
  96 #   endif
  97 # else
  98 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
  99 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 100 #   else
 101 #     define SWIGEXPORT
 102 #   endif
 103 # endif
 104 #endif
 105
 106 /* calling conventions for Windows */
 107 #ifndef SWIGSTDCALL
 108 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 109 #   define SWIGSTDCALL __stdcall
 110 # else
 111 #   define SWIGSTDCALL
 112 # endif
 113 #endif
 114
 115 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 116 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 117 # define _CRT_SECURE_NO_DEPRECATE
 118 #endif
 119
 120 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 121 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 122 # define _SCL_SECURE_NO_DEPRECATE
 123 #endif
 124
 125
 126 /* -----------------------------------------------------------------------------
 127  * swigrun.swg
 128  *
 129  * This file contains generic C API SWIG runtime support for pointer
 130  * type checking.
 131  * ----------------------------------------------------------------------------- */
 132
 133 /* This should only be incremented when either the layout of swig_type_info changes,
 134    or for whatever reason, the runtime changes incompatibly */
 135 #define SWIG_RUNTIME_VERSION "4"
 136
 137 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 138 #ifdef SWIG_TYPE_TABLE
 139 # define SWIG_QUOTE_STRING(x) #x
 140 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 141 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 142 #else
 143 # define SWIG_TYPE_TABLE_NAME
 144 #endif
 145
 146 /*
 147   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 148   creating a static or dynamic library from the SWIG runtime code.
 149   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
 150
 151   But only do this if strictly necessary, ie, if you have problems
 152   with your compiler or suchlike.
 153 */
 154
 155 #ifndef SWIGRUNTIME
 156 # define SWIGRUNTIME SWIGINTERN
 157 #endif
 158
 159 #ifndef SWIGRUNTIMEINLINE
 160 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 161 #endif
 162
 163 /*  Generic buffer size */
 164 #ifndef SWIG_BUFFER_SIZE
 165 # define SWIG_BUFFER_SIZE 1024
 166 #endif
 167
 168 /* Flags for pointer conversions */
 169 #define SWIG_POINTER_DISOWN        0x1
 170 #define SWIG_CAST_NEW_MEMORY       0x2
 171
 172 /* Flags for new pointer objects */
 173 #define SWIG_POINTER_OWN           0x1
 174
 175
 176 /*
 177    Flags/methods for returning states.
 178
 179    The SWIG conversion methods, as ConvertPtr, return and integer
 180    that tells if the conversion was successful or not. And if not,
 181    an error code can be returned (see swigerrors.swg for the codes).
 182
 183    Use the following macros/flags to set or process the returning
 184    states.
 185
 186    In old versions of SWIG, code such as the following was usually written:
 187
 188      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 189        // success code
 190      } else {
 191        //fail code
 192      }
 193
 194    Now you can be more explicit:
 195
 196     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 197     if (SWIG_IsOK(res)) {
 198       // success code
 199     } else {
 200       // fail code
 201     }
 202
 203    which is the same really, but now you can also do
 204
 205     Type *ptr;
 206     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 207     if (SWIG_IsOK(res)) {
 208       // success code
 209       if (SWIG_IsNewObj(res) {
 210         ...
 211         delete *ptr;
 212       } else {
 213         ...
 214       }
 215     } else {
 216       // fail code
 217     }
 218
 219    I.e., now SWIG_ConvertPtr can return new objects and you can
 220    identify the case and take care of the deallocation. Of course that
 221    also requires SWIG_ConvertPtr to return new result values, such as
 222
 223       int SWIG_ConvertPtr(obj, ptr,...) {
 224         if (<obj is ok>) {
 225           if (<need new object>) {
 226             *ptr = <ptr to new allocated object>;
 227             return SWIG_NEWOBJ;
 228           } else {
 229             *ptr = <ptr to old object>;
 230             return SWIG_OLDOBJ;
 231           }
 232         } else {
 233           return SWIG_BADOBJ;
 234         }
 235       }
 236
 237    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 238    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 239    SWIG errors code.
 240
 241    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 242    allows to return the 'cast rank', for example, if you have this
 243
 244        int food(double)
 245        int fooi(int);
 246
 247    and you call
 248
 249       food(1)   // cast rank '1'  (1 -> 1.0)
 250       fooi(1)   // cast rank '0'
 251
 252    just use the SWIG_AddCast()/SWIG_CheckState()
 253 */
 254
 255 #define SWIG_OK                    (0)
 256 #define SWIG_ERROR                 (-1)
 257 #define SWIG_IsOK(r)               (r >= 0)
 258 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 259
 260 /* The CastRankLimit says how many bits are used for the cast rank */
 261 #define SWIG_CASTRANKLIMIT         (1 << 8)
 262 /* The NewMask denotes the object was created (using new/malloc) */
 263 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 264 /* The TmpMask is for in/out typemaps that use temporal objects */
 265 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 266 /* Simple returning values */
 267 #define SWIG_BADOBJ                (SWIG_ERROR)
 268 #define SWIG_OLDOBJ                (SWIG_OK)
 269 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 270 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 271 /* Check, add and del mask methods */
 272 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 273 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 274 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 275 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 276 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 277 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 278
 279 /* Cast-Rank Mode */
 280 #if defined(SWIG_CASTRANK_MODE)
 281 #  ifndef SWIG_TypeRank
 282 #    define SWIG_TypeRank             unsigned long
 283 #  endif
 284 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 285 #    define SWIG_MAXCASTRANK          (2)
 286 #  endif
 287 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 288 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 289 SWIGINTERNINLINE int SWIG_AddCast(int r) {
 290   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 291 }
 292 SWIGINTERNINLINE int SWIG_CheckState(int r) {
 293   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
 294 }
 295 #else /* no cast-rank mode */
 296 #  define SWIG_AddCast
 297 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 298 #endif
 299
 300
 301 #include <string.h>
 302
 303 #ifdef __cplusplus
 304 extern "C" {
 305 #endif
 306
 307 typedef void *(*swig_converter_func)(void *, int *);
 308 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 309
 310 /* Structure to store information on one type */
 311 typedef struct swig_type_info {
 312   const char             *name;                 /* mangled name of this type */
 313   const char             *str;                  /* human readable name of this type */
 314   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 315   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 316   void                   *clientdata;           /* language specific type data */
 317   int                    owndata;               /* flag if the structure owns the clientdata */
 318 } swig_type_info;
 319
 320 /* Structure to store a type and conversion function used for casting */
 321 typedef struct swig_cast_info {
 322   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 323   swig_converter_func     converter;            /* function to cast the void pointers */
 324   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 325   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 326 } swig_cast_info;
 327
 328 /* Structure used to store module information
 329  * Each module generates one structure like this, and the runtime collects
 330  * all of these structures and stores them in a circularly linked list.*/
 331 typedef struct swig_module_info {
 332   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 333   size_t                 size;                  /* Number of types in this module */
 334   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 335   swig_type_info         **type_initial;        /* Array of initially generated type structures */
 336   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 337   void                    *clientdata;          /* Language specific module data */
 338 } swig_module_info;
 339
 340 /*
 341   Compare two type names skipping the space characters, therefore
 342   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 343
 344   Return 0 when the two name types are equivalent, as in
 345   strncmp, but skipping ' '.
 346 */
 347 SWIGRUNTIME int
 348 SWIG_TypeNameComp(const char *f1, const char *l1,
 349                   const char *f2, const char *l2) {
 350   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 351     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 352     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 353     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 354   }
 355   return (int)((l1 - f1) - (l2 - f2));
 356 }
 357
 358 /*
 359   Check type equivalence in a name list like <name1>|<name2>|...
 360   Return 0 if not equal, 1 if equal
 361 */
 362 SWIGRUNTIME int
 363 SWIG_TypeEquiv(const char *nb, const char *tb) {
 364   int equiv = 0;
 365   const char* te = tb + strlen(tb);
 366   const char* ne = nb;
 367   while (!equiv && *ne) {
 368     for (nb = ne; *ne; ++ne) {
 369       if (*ne == '|') break;
 370     }
 371     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 372     if (*ne) ++ne;
 373   }
 374   return equiv;
 375 }
 376
 377 /*
 378   Check type equivalence in a name list like <name1>|<name2>|...
 379   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 380 */
 381 SWIGRUNTIME int
 382 SWIG_TypeCompare(const char *nb, const char *tb) {
 383   int equiv = 0;
 384   const char* te = tb + strlen(tb);
 385   const char* ne = nb;
 386   while (!equiv && *ne) {
 387     for (nb = ne; *ne; ++ne) {
 388       if (*ne == '|') break;
 389     }
 390     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 391     if (*ne) ++ne;
 392   }
 393   return equiv;
 394 }
 395
 396
 397 /*
 398   Check the typename
 399 */
 400 SWIGRUNTIME swig_cast_info *
 401 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 402   if (ty) {
 403     swig_cast_info *iter = ty->cast;
 404     while (iter) {
 405       if (strcmp(iter->type->name, c) == 0) {
 406         if (iter == ty->cast)
 407           return iter;
 408         /* Move iter to the top of the linked list */
 409         iter->prev->next = iter->next;
 410         if (iter->next)
 411           iter->next->prev = iter->prev;
 412         iter->next = ty->cast;
 413         iter->prev = 0;
 414         if (ty->cast) ty->cast->prev = iter;
 415         ty->cast = iter;
 416         return iter;
 417       }
 418       iter = iter->next;
 419     }
 420   }
 421   return 0;
 422 }
 423
 424 /*
 425   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
 426 */
 427 SWIGRUNTIME swig_cast_info *
 428 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
 429   if (ty) {
 430     swig_cast_info *iter = ty->cast;
 431     while (iter) {
 432       if (iter->type == from) {
 433         if (iter == ty->cast)
 434           return iter;
 435         /* Move iter to the top of the linked list */
 436         iter->prev->next = iter->next;
 437         if (iter->next)
 438           iter->next->prev = iter->prev;
 439         iter->next = ty->cast;
 440         iter->prev = 0;
 441         if (ty->cast) ty->cast->prev = iter;
 442         ty->cast = iter;
 443         return iter;
 444       }
 445       iter = iter->next;
 446     }
 447   }
 448   return 0;
 449 }
 450
 451 /*
 452   Cast a pointer up an inheritance hierarchy
 453 */
 454 SWIGRUNTIMEINLINE void *
 455 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
 456   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 457 }
 458
 459 /*
 460    Dynamic pointer casting. Down an inheritance hierarchy
 461 */
 462 SWIGRUNTIME swig_type_info *
 463 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 464   swig_type_info *lastty = ty;
 465   if (!ty || !ty->dcast) return ty;
 466   while (ty && (ty->dcast)) {
 467     ty = (*ty->dcast)(ptr);
 468     if (ty) lastty = ty;
 469   }
 470   return lastty;
 471 }
 472
 473 /*
 474   Return the name associated with this type
 475 */
 476 SWIGRUNTIMEINLINE const char *
 477 SWIG_TypeName(const swig_type_info *ty) {
 478   return ty->name;
 479 }
 480
 481 /*
 482   Return the pretty name associated with this type,
 483   that is an unmangled type name in a form presentable to the user.
 484 */
 485 SWIGRUNTIME const char *
 486 SWIG_TypePrettyName(const swig_type_info *type) {
 487   /* The "str" field contains the equivalent pretty names of the
 488      type, separated by vertical-bar characters.  We choose
 489      to print the last name, as it is often (?) the most
 490      specific. */
 491   if (!type) return NULL;
 492   if (type->str != NULL) {
 493     const char *last_name = type->str;
 494     const char *s;
 495     for (s = type->str; *s; s++)
 496       if (*s == '|') last_name = s+1;
 497     return last_name;
 498   }
 499   else
 500     return type->name;
 501 }
 502
 503 /*
 504    Set the clientdata field for a type
 505 */
 506 SWIGRUNTIME void
 507 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 508   swig_cast_info *cast = ti->cast;
 509   /* if (ti->clientdata == clientdata) return; */
 510   ti->clientdata = clientdata;
 511
 512   while (cast) {
 513     if (!cast->converter) {
 514       swig_type_info *tc = cast->type;
 515       if (!tc->clientdata) {
 516         SWIG_TypeClientData(tc, clientdata);
 517       }
 518     }
 519     cast = cast->next;
 520   }
 521 }
 522 SWIGRUNTIME void
 523 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 524   SWIG_TypeClientData(ti, clientdata);
 525   ti->owndata = 1;
 526 }
 527
 528 /*
 529   Search for a swig_type_info structure only by mangled name
 530   Search is a O(log #types)
 531
 532   We start searching at module start, and finish searching when start == end.
 533   Note: if start == end at the beginning of the function, we go all the way around
 534   the circular list.
 535 */
 536 SWIGRUNTIME swig_type_info *
 537 SWIG_MangledTypeQueryModule(swig_module_info *start,
 538                             swig_module_info *end,
 539                             const char *name) {
 540   swig_module_info *iter = start;
 541   do {
 542     if (iter->size) {
 543       register size_t l = 0;
 544       register size_t r = iter->size - 1;
 545       do {
 546         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 547         register size_t i = (l + r) >> 1;
 548         const char *iname = iter->types[i]->name;
 549         if (iname) {
 550           register int compare = strcmp(name, iname);
 551           if (compare == 0) {
 552             return iter->types[i];
 553           } else if (compare < 0) {
 554             if (i) {
 555               r = i - 1;
 556             } else {
 557               break;
 558             }
 559           } else if (compare > 0) {
 560             l = i + 1;
 561           }
 562         } else {
 563           break; /* should never happen */
 564         }
 565       } while (l <= r);
 566     }
 567     iter = iter->next;
 568   } while (iter != end);
 569   return 0;
 570 }
 571
 572 /*
 573   Search for a swig_type_info structure for either a mangled name or a human readable name.
 574   It first searches the mangled names of the types, which is a O(log #types)
 575   If a type is not found it then searches the human readable names, which is O(#types).
 576
 577   We start searching at module start, and finish searching when start == end.
 578   Note: if start == end at the beginning of the function, we go all the way around
 579   the circular list.
 580 */
 581 SWIGRUNTIME swig_type_info *
 582 SWIG_TypeQueryModule(swig_module_info *start,
 583                      swig_module_info *end,
 584                      const char *name) {
 585   /* STEP 1: Search the name field using binary search */
 586   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 587   if (ret) {
 588     return ret;
 589   } else {
 590     /* STEP 2: If the type hasn't been found, do a complete search
 591        of the str field (the human readable name) */
 592     swig_module_info *iter = start;
 593     do {
 594       register size_t i = 0;
 595       for (; i < iter->size; ++i) {
 596         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 597           return iter->types[i];
 598       }
 599       iter = iter->next;
 600     } while (iter != end);
 601   }
 602
 603   /* neither found a match */
 604   return 0;
 605 }
 606
 607 /*
 608    Pack binary data into a string
 609 */
 610 SWIGRUNTIME char *
 611 SWIG_PackData(char *c, void *ptr, size_t sz) {
 612   static const char hex[17] = "0123456789abcdef";
 613   register const unsigned char *u = (unsigned char *) ptr;
 614   register const unsigned char *eu =  u + sz;
 615   for (; u != eu; ++u) {
 616     register unsigned char uu = *u;
 617     *(c++) = hex[(uu & 0xf0) >> 4];
 618     *(c++) = hex[uu & 0xf];
 619   }
 620   return c;
 621 }
 622
 623 /*
 624    Unpack binary data from a string
 625 */
 626 SWIGRUNTIME const char *
 627 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 628   register unsigned char *u = (unsigned char *) ptr;
 629   register const unsigned char *eu = u + sz;
 630   for (; u != eu; ++u) {
 631     register char d = *(c++);
 632     register unsigned char uu;
 633     if ((d >= '0') && (d <= '9'))
 634       uu = ((d - '0') << 4);
 635     else if ((d >= 'a') && (d <= 'f'))
 636       uu = ((d - ('a'-10)) << 4);
 637     else
 638       return (char *) 0;
 639     d = *(c++);
 640     if ((d >= '0') && (d <= '9'))
 641       uu |= (d - '0');
 642     else if ((d >= 'a') && (d <= 'f'))
 643       uu |= (d - ('a'-10));
 644     else
 645       return (char *) 0;
 646     *u = uu;
 647   }
 648   return c;
 649 }
 650
 651 /*
 652    Pack 'void *' into a string buffer.
 653 */
 654 SWIGRUNTIME char *
 655 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 656   char *r = buff;
 657   if ((2*sizeof(void *) + 2) > bsz) return 0;
 658   *(r++) = '_';
 659   r = SWIG_PackData(r,&ptr,sizeof(void *));
 660   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 661   strcpy(r,name);
 662   return buff;
 663 }
 664
 665 SWIGRUNTIME const char *
 666 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 667   if (*c != '_') {
 668     if (strcmp(c,"NULL") == 0) {
 669       *ptr = (void *) 0;
 670       return name;
 671     } else {
 672       return 0;
 673     }
 674   }
 675   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 676 }
 677
 678 SWIGRUNTIME char *
 679 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 680   char *r = buff;
 681   size_t lname = (name ? strlen(name) : 0);
 682   if ((2*sz + 2 + lname) > bsz) return 0;
 683   *(r++) = '_';
 684   r = SWIG_PackData(r,ptr,sz);
 685   if (lname) {
 686     strncpy(r,name,lname+1);
 687   } else {
 688     *r = 0;
 689   }
 690   return buff;
 691 }
 692
 693 SWIGRUNTIME const char *
 694 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 695   if (*c != '_') {
 696     if (strcmp(c,"NULL") == 0) {
 697       memset(ptr,0,sz);
 698       return name;
 699     } else {
 700       return 0;
 701     }
 702   }
 703   return SWIG_UnpackData(++c,ptr,sz);
 704 }
 705
 706 #ifdef __cplusplus
 707 }
 708 #endif
 709
 710 /*  Errors in SWIG */
 711 #define  SWIG_UnknownError         -1
 712 #define  SWIG_IOError              -2
 713 #define  SWIG_RuntimeError         -3
 714 #define  SWIG_IndexError           -4
 715 #define  SWIG_TypeError            -5
 716 #define  SWIG_DivisionByZero       -6
 717 #define  SWIG_OverflowError        -7
 718 #define  SWIG_SyntaxError          -8
 719 #define  SWIG_ValueError           -9
 720 #define  SWIG_SystemError          -10
 721 #define  SWIG_AttributeError       -11
 722 #define  SWIG_MemoryError          -12
 723 #define  SWIG_NullReferenceError   -13
 724
 725
 726
 727 #ifdef __cplusplus
 728 /* Needed on some windows machines---since MS plays funny games with the header files under C++ */
 729 #include <math.h>
 730 #include <stdlib.h>
 731 extern "C" {
 732 #endif
 733 #include "EXTERN.h"
 734 #include "perl.h"
 735 #include "XSUB.h"
 736
 737 /* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
 738
 739 /* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
 740 #ifndef PERL_REVISION
 741 #  if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
 742 #    define PERL_PATCHLEVEL_H_IMPLICIT
 743 #    include <patchlevel.h>
 744 #  endif
 745 #  if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
 746 #    include <could_not_find_Perl_patchlevel.h>
 747 #  endif
 748 #  ifndef PERL_REVISION
 749 #    define PERL_REVISION       (5)
 750 #    define PERL_VERSION        PATCHLEVEL
 751 #    define PERL_SUBVERSION     SUBVERSION
 752 #  endif
 753 #endif
 754
 755 #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
 756 #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
 757 #endif
 758
 759 #ifndef SvIOK_UV
 760 # define SvIOK_UV(sv)       (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
 761 #endif
 762
 763 #ifndef SvUOK
 764 # define SvUOK(sv)           SvIOK_UV(sv)
 765 #endif
 766
 767 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
 768 #  define PL_sv_undef               sv_undef
 769 #  define PL_na                     na
 770 #  define PL_errgv                  errgv
 771 #  define PL_sv_no                  sv_no
 772 #  define PL_sv_yes                 sv_yes
 773 #  define PL_markstack_ptr          markstack_ptr
 774 #endif
 775
 776 #ifndef IVSIZE
 777 #  ifdef LONGSIZE
 778 #    define IVSIZE LONGSIZE
 779 #  else
 780 #    define IVSIZE 4 /* A bold guess, but the best we can make. */
 781 #  endif
 782 #endif
 783
 784 #ifndef INT2PTR
 785 #  if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
 786 #    define PTRV                  UV
 787 #    define INT2PTR(any,d)        (any)(d)
 788 #  else
 789 #    if PTRSIZE == LONGSIZE
 790 #      define PTRV                unsigned long
 791 #    else
 792 #      define PTRV                unsigned
 793 #    endif
 794 #    define INT2PTR(any,d)        (any)(PTRV)(d)
 795 #  endif
 796
 797 #  define NUM2PTR(any,d)  (any)(PTRV)(d)
 798 #  define PTR2IV(p)       INT2PTR(IV,p)
 799 #  define PTR2UV(p)       INT2PTR(UV,p)
 800 #  define PTR2NV(p)       NUM2PTR(NV,p)
 801
 802 #  if PTRSIZE == LONGSIZE
 803 #    define PTR2ul(p)     (unsigned long)(p)
 804 #  else
 805 #    define PTR2ul(p)     INT2PTR(unsigned long,p)
 806 #  endif
 807 #endif /* !INT2PTR */
 808
 809 #ifndef SvPV_nolen
 810 # define SvPV_nolen(x) SvPV(x,PL_na)
 811 #endif
 812
 813 #ifndef get_sv
 814 #  define get_sv perl_get_sv
 815 #endif
 816
 817 #ifndef ERRSV
 818 #  define ERRSV get_sv("@",FALSE)
 819 #endif
 820
 821 #ifndef pTHX_
 822 #define pTHX_
 823 #endif
 824
 825 #include <string.h>
 826 #ifdef __cplusplus
 827 }
 828 #endif
 829
 830 /* -----------------------------------------------------------------------------
 831  * error manipulation
 832  * ----------------------------------------------------------------------------- */
 833
 834 SWIGINTERN const char*
 835 SWIG_Perl_ErrorType(int code) {
 836   const char* type = 0;
 837   switch(code) {
 838   case SWIG_MemoryError:
 839     type = "MemoryError";
 840     break;
 841   case SWIG_IOError:
 842     type = "IOError";
 843     break;
 844   case SWIG_RuntimeError:
 845     type = "RuntimeError";
 846     break;
 847   case SWIG_IndexError:
 848     type = "IndexError";
 849     break;
 850   case SWIG_TypeError:
 851     type = "TypeError";
 852     break;
 853   case SWIG_DivisionByZero:
 854     type = "ZeroDivisionError";
 855     break;
 856   case SWIG_OverflowError:
 857     type = "OverflowError";
 858     break;
 859   case SWIG_SyntaxError:
 860     type = "SyntaxError";
 861     break;
 862   case SWIG_ValueError:
 863     type = "ValueError";
 864     break;
 865   case SWIG_SystemError:
 866     type = "SystemError";
 867     break;
 868   case SWIG_AttributeError:
 869     type = "AttributeError";
 870     break;
 871   default:
 872     type = "RuntimeError";
 873   }
 874   return type;
 875 }
 876
 877
 878
 879
 880 /* -----------------------------------------------------------------------------
 881  * perlrun.swg
 882  *
 883  * This file contains the runtime support for Perl modules
 884  * and includes code for managing global variables and pointer
 885  * type checking.
 886  * ----------------------------------------------------------------------------- */
 887
 888 #ifdef PERL_OBJECT
 889 #define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
 890 #define SWIG_PERL_OBJECT_CALL pPerl,
 891 #else
 892 #define SWIG_PERL_OBJECT_DECL
 893 #define SWIG_PERL_OBJECT_CALL
 894 #endif
 895
 896 /* Common SWIG API */
 897
 898 /* for raw pointers */
 899 #define SWIG_ConvertPtr(obj, pp, type, flags)           SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
 900 #define SWIG_NewPointerObj(p, type, flags)              SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
 901
 902 /* for raw packed data */
 903 #define SWIG_ConvertPacked(obj, p, s, type)             SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
 904 #define SWIG_NewPackedObj(p, s, type)                   SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
 905
 906 /* for class or struct pointers */
 907 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
 908 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
 909
 910 /* for C or C++ function pointers */
 911 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
 912 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
 913
 914 /* for C++ member pointers, ie, member methods */
 915 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_ConvertPacked(obj, ptr, sz, ty)
 916 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_NewPackedObj(ptr, sz, type)
 917
 918
 919 /* Runtime API */
 920
 921 #define SWIG_GetModule(clientdata)                      SWIG_Perl_GetModule()
 922 #define SWIG_SetModule(clientdata, pointer)             SWIG_Perl_SetModule(pointer)
 923
 924
 925 /* Error manipulation */
 926
 927 #define SWIG_ErrorType(code)                            SWIG_Perl_ErrorType(code)
 928 #define SWIG_Error(code, msg)                           sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg)
 929 #define SWIG_fail                                       goto fail
 930
 931 /* Perl-specific SWIG API */
 932
 933 #define SWIG_MakePtr(sv, ptr, type, flags)              SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
 934 #define SWIG_MakePackedObj(sv, p, s, type)              SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
 935 #define SWIG_SetError(str)                              SWIG_Error(SWIG_RuntimeError, str)
 936
 937
 938 #define SWIG_PERL_DECL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_DECL arg1)
 939 #define SWIG_PERL_CALL_ARGS_1(arg1)                     (SWIG_PERL_OBJECT_CALL arg1)
 940 #define SWIG_PERL_DECL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_DECL arg1, arg2)
 941 #define SWIG_PERL_CALL_ARGS_2(arg1, arg2)               (SWIG_PERL_OBJECT_CALL arg1, arg2)
 942
 943 /* -----------------------------------------------------------------------------
 944  * pointers/data manipulation
 945  * ----------------------------------------------------------------------------- */
 946
 947 /* For backward compatibility only */
 948 #define SWIG_POINTER_EXCEPTION  0
 949
 950 #ifdef __cplusplus
 951 extern "C" {
 952 #endif
 953
 954 #define SWIG_OWNER   SWIG_POINTER_OWN
 955 #define SWIG_SHADOW  SWIG_OWNER << 1
 956
 957 #define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
 958
 959 /* SWIG Perl macros */
 960
 961 /* Macro to declare an XS function */
 962 #ifndef XSPROTO
 963 #   define XSPROTO(name) void name(pTHX_ CV* cv)
 964 #endif
 965
 966 /* Macro to call an XS function */
 967 #ifdef PERL_OBJECT
 968 #  define SWIG_CALLXS(_name) _name(cv,pPerl)
 969 #else
 970 #  ifndef MULTIPLICITY
 971 #    define SWIG_CALLXS(_name) _name(cv)
 972 #  else
 973 #    define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
 974 #  endif
 975 #endif
 976
 977 #ifdef PERL_OBJECT
 978 #define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
 979
 980 #ifdef __cplusplus
 981 extern "C" {
 982 #endif
 983 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
 984 #ifdef __cplusplus
 985 }
 986 #endif
 987
 988 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
 989 #define SWIGCLASS_STATIC
 990
 991 #else /* PERL_OBJECT */
 992
 993 #define MAGIC_PPERL
 994 #define SWIGCLASS_STATIC static SWIGUNUSED
 995
 996 #ifndef MULTIPLICITY
 997 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
 998
 999 #ifdef __cplusplus
1000 extern "C" {
1001 #endif
1002 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
1003 #ifdef __cplusplus
1004 }
1005 #endif
1006
1007 #else /* MULTIPLICITY */
1008
1009 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
1010
1011 #ifdef __cplusplus
1012 extern "C" {
1013 #endif
1014 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
1015 #ifdef __cplusplus
1016 }
1017 #endif
1018
1019 #endif /* MULTIPLICITY */
1020 #endif /* PERL_OBJECT */
1021
1022 /* Workaround for bug in perl 5.6.x croak and earlier */
1023 #if (PERL_VERSION < 8)
1024 #  ifdef PERL_OBJECT
1025 #    define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
1026 static void SWIG_Perl_croak_null(CPerlObj *pPerl)
1027 #  else
1028 static void SWIG_croak_null()
1029 #  endif
1030 {
1031   SV *err=ERRSV;
1032 #  if (PERL_VERSION < 6)
1033   croak("%_", err);
1034 #  else
1035   if (SvOK(err) && !SvROK(err)) croak("%_", err);
1036   croak(Nullch);
1037 #  endif
1038 }
1039 #else
1040 #  define SWIG_croak_null() croak(Nullch)
1041 #endif
1042
1043
1044 /*
1045    Define how strict is the cast between strings and integers/doubles
1046    when overloading between these types occurs.
1047
1048    The default is making it as strict as possible by using SWIG_AddCast
1049    when needed.
1050
1051    You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
1052    disable the SWIG_AddCast, making the casting between string and
1053    numbers less strict.
1054
1055    In the end, we try to solve the overloading between strings and
1056    numerical types in the more natural way, but if you can avoid it,
1057    well, avoid it using %rename, for example.
1058 */
1059 #ifndef SWIG_PERL_NO_STRICT_STR2NUM
1060 # ifndef SWIG_PERL_STRICT_STR2NUM
1061 #  define SWIG_PERL_STRICT_STR2NUM
1062 # endif
1063 #endif
1064 #ifdef SWIG_PERL_STRICT_STR2NUM
1065 /* string takes precedence */
1066 #define SWIG_Str2NumCast(x) SWIG_AddCast(x)
1067 #else
1068 /* number takes precedence */
1069 #define SWIG_Str2NumCast(x) x
1070 #endif
1071
1072
1073
1074 #include <stdlib.h>
1075
1076 SWIGRUNTIME const char *
1077 SWIG_Perl_TypeProxyName(const swig_type_info *type) {
1078   if (!type) return NULL;
1079   if (type->clientdata != NULL) {
1080     return (const char*) type->clientdata;
1081   }
1082   else {
1083     return type->name;
1084   }
1085 }
1086
1087 /* Identical to SWIG_TypeCheck, except for strcmp comparison */
1088 SWIGRUNTIME swig_cast_info *
1089 SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
1090   if (ty) {
1091     swig_cast_info *iter = ty->cast;
1092     while (iter) {
1093       if ( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0)) ||
1094             (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0)) ) {
1095         if (iter == ty->cast)
1096           return iter;
1097         /* Move iter to the top of the linked list */
1098         iter->prev->next = iter->next;
1099         if (iter->next)
1100           iter->next->prev = iter->prev;
1101         iter->next = ty->cast;
1102         iter->prev = 0;
1103         if (ty->cast) ty->cast->prev = iter;
1104         ty->cast = iter;
1105         return iter;
1106       }
1107       iter = iter->next;
1108     }
1109   }
1110   return 0;
1111 }
1112
1113 /* Function for getting a pointer value */
1114
1115 SWIGRUNTIME int
1116 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
1117   swig_cast_info *tc;
1118   void *voidptr = (void *)0;
1119   SV *tsv = 0;
1120   /* If magical, apply more magic */
1121   if (SvGMAGICAL(sv))
1122     mg_get(sv);
1123
1124   /* Check to see if this is an object */
1125   if (sv_isobject(sv)) {
1126     IV tmp = 0;
1127     tsv = (SV*) SvRV(sv);
1128     if ((SvTYPE(tsv) == SVt_PVHV)) {
1129       MAGIC *mg;
1130       if (SvMAGICAL(tsv)) {
1131         mg = mg_find(tsv,'P');
1132         if (mg) {
1133           sv = mg->mg_obj;
1134           if (sv_isobject(sv)) {
1135             tsv = (SV*)SvRV(sv);
1136             tmp = SvIV(tsv);
1137           }
1138         }
1139       } else {
1140         return SWIG_ERROR;
1141       }
1142     } else {
1143       tmp = SvIV(tsv);
1144     }
1145     voidptr = INT2PTR(void *,tmp);
1146   } else if (! SvOK(sv)) {            /* Check for undef */
1147     *(ptr) = (void *) 0;
1148     return SWIG_OK;
1149   } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
1150     if (!SvROK(sv)) {
1151       *(ptr) = (void *) 0;
1152       return SWIG_OK;
1153     } else {
1154       return SWIG_ERROR;
1155     }
1156   } else {                            /* Don't know what it is */
1157     return SWIG_ERROR;
1158   }
1159   if (_t) {
1160     /* Now see if the types match */
1161     char *_c = HvNAME(SvSTASH(SvRV(sv)));
1162     tc = SWIG_TypeProxyCheck(_c,_t);
1163     if (!tc) {
1164       return SWIG_ERROR;
1165     }
1166     {
1167       int newmemory = 0;
1168       *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
1169       assert(!newmemory); /* newmemory handling not yet implemented */
1170     }
1171   } else {
1172     *ptr = voidptr;
1173   }
1174
1175   /*
1176    *  DISOWN implementation: we need a perl guru to check this one.
1177    */
1178   if (tsv && (flags & SWIG_POINTER_DISOWN)) {
1179     /*
1180      *  almost copy paste code from below SWIG_POINTER_OWN setting
1181      */
1182     SV *obj = sv;
1183     HV *stash = SvSTASH(SvRV(obj));
1184     GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
1185     if (isGV(gv)) {
1186       HV *hv = GvHVn(gv);
1187       /*
1188        * To set ownership (see below), a newSViv(1) entry is added.
1189        * Hence, to remove ownership, we delete the entry.
1190        */
1191       if (hv_exists_ent(hv, obj, 0)) {
1192         hv_delete_ent(hv, obj, 0, 0);
1193       }
1194     }
1195   }
1196   return SWIG_OK;
1197 }
1198
1199 SWIGRUNTIME void
1200 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
1201   if (ptr && (flags & SWIG_SHADOW)) {
1202     SV *self;
1203     SV *obj=newSV(0);
1204     HV *hash=newHV();
1205     HV *stash;
1206     sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1207     stash=SvSTASH(SvRV(obj));
1208     if (flags & SWIG_POINTER_OWN) {
1209       HV *hv;
1210       GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1211       if (!isGV(gv))
1212         gv_init(gv, stash, "OWNER", 5, FALSE);
1213       hv=GvHVn(gv);
1214       hv_store_ent(hv, obj, newSViv(1), 0);
1215     }
1216     sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
1217     SvREFCNT_dec(obj);
1218     self=newRV_noinc((SV *)hash);
1219     sv_setsv(sv, self);
1220     SvREFCNT_dec((SV *)self);
1221     sv_bless(sv, stash);
1222   }
1223   else {
1224     sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1225   }
1226 }
1227
1228 SWIGRUNTIMEINLINE SV *
1229 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
1230   SV *result = sv_newmortal();
1231   SWIG_MakePtr(result, ptr, t, flags);
1232   return result;
1233 }
1234
1235 SWIGRUNTIME void
1236 SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
1237   char result[1024];
1238   char *r = result;
1239   if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
1240   *(r++) = '_';
1241   r = SWIG_PackData(r,ptr,sz);
1242   strcpy(r,SWIG_Perl_TypeProxyName(type));
1243   sv_setpv(sv, result);
1244 }
1245
1246 SWIGRUNTIME SV *
1247 SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
1248   SV *result = sv_newmortal();
1249   SWIG_Perl_MakePackedObj(result, ptr, sz, type);
1250   return result;
1251 }
1252
1253 /* Convert a packed value value */
1254 SWIGRUNTIME int
1255 SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
1256   swig_cast_info *tc;
1257   const char  *c = 0;
1258
1259   if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
1260   c = SvPV_nolen(obj);
1261   /* Pointer values must start with leading underscore */
1262   if (*c != '_') return SWIG_ERROR;
1263   c++;
1264   c = SWIG_UnpackData(c,ptr,sz);
1265   if (ty) {
1266     tc = SWIG_TypeCheck(c,ty);
1267     if (!tc) return SWIG_ERROR;
1268   }
1269   return SWIG_OK;
1270 }
1271
1272
1273 /* Macros for low-level exception handling */
1274 #define SWIG_croak(x)    { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
1275
1276
1277 typedef XSPROTO(SwigPerlWrapper);
1278 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
1279
1280 /* Structure for command table */
1281 typedef struct {
1282   const char         *name;
1283   SwigPerlWrapperPtr  wrapper;
1284 } swig_command_info;
1285
1286 /* Information for constant table */
1287
1288 #define SWIG_INT     1
1289 #define SWIG_FLOAT   2
1290 #define SWIG_STRING  3
1291 #define SWIG_POINTER 4
1292 #define SWIG_BINARY  5
1293
1294 /* Constant information structure */
1295 typedef struct swig_constant_info {
1296     int              type;
1297     const char      *name;
1298     long             lvalue;
1299     double           dvalue;
1300     void            *pvalue;
1301     swig_type_info **ptype;
1302 } swig_constant_info;
1303
1304
1305 /* Structure for variable table */
1306 typedef struct {
1307   const char   *name;
1308   SwigMagicFunc   set;
1309   SwigMagicFunc   get;
1310   swig_type_info  **type;
1311 } swig_variable_info;
1312
1313 /* Magic variable code */
1314 #ifndef PERL_OBJECT
1315 #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
1316   #ifndef MULTIPLICITY
1317      SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
1318   #else
1319      SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
1320   #endif
1321 #else
1322 #  define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
1323 SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
1324 #endif
1325 {
1326   MAGIC *mg;
1327   sv_magic(sv,sv,'U',(char *) name,strlen(name));
1328   mg = mg_find(sv,'U');
1329   mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
1330   mg->mg_virtual->svt_get = (SwigMagicFunc) get;
1331   mg->mg_virtual->svt_set = (SwigMagicFunc) set;
1332   mg->mg_virtual->svt_len = 0;
1333   mg->mg_virtual->svt_clear = 0;
1334   mg->mg_virtual->svt_free = 0;
1335 }
1336
1337
1338 SWIGRUNTIME swig_module_info *
1339 SWIG_Perl_GetModule(void) {
1340   static void *type_pointer = (void *)0;
1341   SV *pointer;
1342
1343   /* first check if pointer already created */
1344   if (!type_pointer) {
1345     pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
1346     if (pointer && SvOK(pointer)) {
1347       type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
1348     }
1349   }
1350
1351   return (swig_module_info *) type_pointer;
1352 }
1353
1354 SWIGRUNTIME void
1355 SWIG_Perl_SetModule(swig_module_info *module) {
1356   SV *pointer;
1357
1358   /* create a new pointer */
1359   pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
1360   sv_setiv(pointer, PTR2IV(module));
1361 }
1362
1363 #ifdef __cplusplus
1364 }
1365 #endif
1366
1367 /* Workaround perl5 global namespace pollution. Note that undefining library
1368  * functions like fopen will not solve the problem on all platforms as fopen
1369  * might be a macro on Windows but not necessarily on other operating systems. */
1370 #ifdef do_open
1371   #undef do_open
1372 #endif
1373 #ifdef do_close
1374   #undef do_close
1375 #endif
1376 #ifdef scalar
1377   #undef scalar
1378 #endif
1379 #ifdef list
1380   #undef list
1381 #endif
1382 #ifdef apply
1383   #undef apply
1384 #endif
1385 #ifdef convert
1386   #undef convert
1387 #endif
1388 #ifdef Error
1389   #undef Error
1390 #endif
1391 #ifdef form
1392   #undef form
1393 #endif
1394 #ifdef vform
1395   #undef vform
1396 #endif
1397 #ifdef LABEL
1398   #undef LABEL
1399 #endif
1400 #ifdef METHOD
1401   #undef METHOD
1402 #endif
1403 #ifdef Move
1404   #undef Move
1405 #endif
1406 #ifdef yylex
1407   #undef yylex
1408 #endif
1409 #ifdef yyparse
1410   #undef yyparse
1411 #endif
1412 #ifdef yyerror
1413   #undef yyerror
1414 #endif
1415 #ifdef invert
1416   #undef invert
1417 #endif
1418 #ifdef ref
1419   #undef ref
1420 #endif
1421 #ifdef read
1422   #undef read
1423 #endif
1424 #ifdef write
1425   #undef write
1426 #endif
1427 #ifdef eof
1428   #undef eof
1429 #endif
1430 #ifdef bool
1431   #undef bool
1432 #endif
1433 #ifdef close
1434   #undef close
1435 #endif
1436 #ifdef rewind
1437   #undef rewind
1438 #endif
1439 #ifdef free
1440   #undef free
1441 #endif
1442 #ifdef malloc
1443   #undef malloc
1444 #endif
1445 #ifdef calloc
1446   #undef calloc
1447 #endif
1448 #ifdef Stat
1449   #undef Stat
1450 #endif
1451 #ifdef check
1452   #undef check
1453 #endif
1454 #ifdef seekdir
1455   #undef seekdir
1456 #endif
1457 #ifdef open
1458   #undef open
1459 #endif
1460 #ifdef readdir
1461   #undef readdir
1462 #endif
1463 #ifdef bind
1464   #undef bind
1465 #endif
1466
1467
1468
1469 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1470
1471 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1472
1473
1474
1475   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
1476
1477
1478 /* -------- TYPES TABLE (BEGIN) -------- */
1479
1480 #define SWIGTYPE_p_Device swig_types[0]
1481 #define SWIGTYPE_p_DevicePropertyBase swig_types[1]
1482 #define SWIGTYPE_p_DirectTCPAddr swig_types[2]
1483 #define SWIGTYPE_p_DirectTCPConnection swig_types[3]
1484 #define SWIGTYPE_p_GSList swig_types[4]
1485 #define SWIGTYPE_p_GValue swig_types[5]
1486 #define SWIGTYPE_p_a_STRMAX__char swig_types[6]
1487 #define SWIGTYPE_p_char swig_types[7]
1488 #define SWIGTYPE_p_double swig_types[8]
1489 #define SWIGTYPE_p_dumpfile_t swig_types[9]
1490 #define SWIGTYPE_p_float swig_types[10]
1491 #define SWIGTYPE_p_guint swig_types[11]
1492 #define SWIGTYPE_p_guint32 swig_types[12]
1493 #define SWIGTYPE_p_guint64 swig_types[13]
1494 #define SWIGTYPE_p_int swig_types[14]
1495 #define SWIGTYPE_p_p_DirectTCPAddr swig_types[15]
1496 #define SWIGTYPE_p_unsigned_char swig_types[16]
1497 static swig_type_info *swig_types[18];
1498 static swig_module_info swig_module = {swig_types, 17, 0, 0, 0, 0};
1499 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1500 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1501
1502 /* -------- TYPES TABLE (END) -------- */
1503
1504 #define SWIG_init    boot_Amanda__Device
1505
1506 #define SWIG_name   "Amanda::Devicec::boot_Amanda__Device"
1507 #define SWIG_prefix "Amanda::Devicec::"
1508
1509 #define SWIGVERSION 0x010339
1510 #define SWIG_VERSION SWIGVERSION
1511
1512
1513 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1514 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1515
1516
1517 #ifdef __cplusplus
1518 extern "C"
1519 #endif
1520 #ifndef PERL_OBJECT
1521 #ifndef MULTIPLICITY
1522 SWIGEXPORT void SWIG_init (CV* cv);
1523 #else
1524 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1525 #endif
1526 #else
1527 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1528 #endif
1529
1530
1531 #include "amglue.h"
1532
1533
1534 #include "amglue.h"
1535
1536
1537 #include "amglue.h"
1538
1539
1540 #include "device.h"
1541 #include "property.h"
1542 #include "fileheader.h"
1543 #include "glib-util.h"
1544 #include "simpleprng.h"
1545 #include "amanda.h"
1546 #include "sockaddr-util.h"
1547
1548
1549
1550 /* Utility functions for typemaps, below */
1551
1552 /* return a new, mortal SV corresponding to the given GValue
1553  *
1554  * @param value: the value to convert
1555  * @returns: a new, mortal SV
1556  */
1557 static SV *
1558 set_sv_from_gvalue(GValue *value)
1559 {
1560     GType fundamental = G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value));
1561     SV *sv = NULL;
1562
1563     /* complex reference types */
1564     switch (fundamental) {
1565         case G_TYPE_LONG:
1566             return sv_2mortal(amglue_newSVi64(g_value_get_long(value)));
1567
1568         case G_TYPE_ULONG:
1569             return sv_2mortal(amglue_newSVu64(g_value_get_ulong(value)));
1570
1571         case G_TYPE_INT64:
1572             return sv_2mortal(amglue_newSVi64(g_value_get_int64(value)));
1573
1574         case G_TYPE_UINT64:
1575             return sv_2mortal(amglue_newSVu64(g_value_get_uint64(value)));
1576     }
1577
1578     /* simple types that can be constructed with sv_set*v */
1579     sv = sv_newmortal();
1580     switch (fundamental) {
1581         case G_TYPE_CHAR:
1582             sv_setiv(sv, g_value_get_char(value));
1583             break;
1584
1585         case G_TYPE_UCHAR:
1586             sv_setuv(sv, g_value_get_uchar(value));
1587             break;
1588
1589         case G_TYPE_BOOLEAN:
1590             sv_setiv(sv, g_value_get_boolean(value));
1591             break;
1592
1593         case G_TYPE_INT:
1594             sv_setiv(sv, g_value_get_int(value));
1595             break;
1596
1597         case G_TYPE_UINT:
1598             sv_setuv(sv, g_value_get_uint(value));
1599             break;
1600
1601         case G_TYPE_FLOAT:
1602             sv_setnv(sv, g_value_get_float(value));
1603             break;
1604
1605         case G_TYPE_DOUBLE:
1606             sv_setnv(sv, g_value_get_double(value));
1607             break;
1608
1609         case G_TYPE_STRING:
1610             sv_setpv(sv, g_value_get_string(value));
1611             break;
1612
1613         case G_TYPE_ENUM:
1614             sv_setiv(sv, g_value_get_enum(value));
1615             break;
1616
1617         case G_TYPE_FLAGS:
1618             sv_setiv(sv, g_value_get_flags(value));
1619             break;
1620
1621         /* Unsupported */
1622         default:
1623         case G_TYPE_POINTER:
1624         case G_TYPE_INTERFACE:
1625         case G_TYPE_OBJECT:
1626         case G_TYPE_PARAM:
1627             warn("Unsupported fundamental property type #%d", (int)fundamental);
1628             sv_setsv(sv, &PL_sv_undef);
1629             break;
1630     }
1631
1632     return sv;
1633 }
1634
1635 /* Given an SV and an initialized GValue, set the GValue to the value
1636  * represented by the SV.  The GValue's type must already be set.
1637  *
1638  * For basic corresponding types (string -> string, integer -> integer),
1639  * the translation is straightforward.  However, if the GValue is not a
1640  * string, but the SV has a string value, then g_value_set_from_string will
1641  * be used to parse the string.
1642  *
1643  * @param sv: SV to convert
1644  * @param value: (input/output) destination
1645  * @returns: TRUE on success
1646  */
1647 static gboolean
1648 set_gvalue_from_sv(SV *sv, GValue *value)
1649 {
1650     GType fundamental = G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value));
1651
1652     /* if we got a string, use g_value_set_from_string to parse any funny
1653      * values or suffixes */
1654     if (SvPOK(sv)) {
1655         if (g_value_set_from_string(value, SvPV_nolen(sv)))
1656             return TRUE;
1657     }
1658
1659     /* otherwise, handle numeric types with SvIV, SvNV, or the amglue_* functions */
1660     switch (fundamental) {
1661         case G_TYPE_BOOLEAN:
1662             g_value_set_boolean(value, SvIV(sv));
1663             return TRUE;
1664
1665         case G_TYPE_CHAR:
1666             g_value_set_char(value, amglue_SvI8(sv));
1667             return TRUE;
1668
1669         case G_TYPE_UCHAR:
1670             g_value_set_uchar(value, amglue_SvU8(sv));
1671             return TRUE;
1672
1673         case G_TYPE_INT:
1674             g_value_set_int(value, amglue_SvI32(sv));
1675             return TRUE;
1676
1677         case G_TYPE_UINT:
1678             g_value_set_uint(value, amglue_SvU32(sv));
1679             return TRUE;
1680
1681         case G_TYPE_LONG:
1682             g_value_set_int64(value, amglue_SvI64(sv));
1683             return TRUE;
1684
1685         case G_TYPE_ULONG:
1686             g_value_set_uint64(value, amglue_SvU64(sv));
1687             return TRUE;
1688
1689         case G_TYPE_INT64:
1690             g_value_set_int64(value, amglue_SvI64(sv));
1691             return TRUE;
1692
1693         case G_TYPE_UINT64:
1694             g_value_set_uint64(value, amglue_SvU64(sv));
1695             return TRUE;
1696
1697         case G_TYPE_FLOAT:
1698             g_value_set_float(value, SvNV(sv));
1699             return TRUE;
1700
1701         case G_TYPE_DOUBLE:
1702             g_value_set_double(value, SvNV(sv));
1703             return TRUE;
1704
1705         case G_TYPE_ENUM:
1706             g_value_set_enum(value, SvIV(sv));
1707             return TRUE;
1708
1709         case G_TYPE_FLAGS:
1710             g_value_set_flags(value, SvIV(sv));
1711             return TRUE;
1712
1713         default:
1714             /* for anything else, let perl stringify it for us and try parsing it */
1715             return g_value_set_from_string(value, SvPV_nolen(sv));
1716     }
1717 }
1718
1719
1720 SWIGINTERN void delete_DirectTCPConnection(DirectTCPConnection *self){
1721             g_object_unref(self);
1722         }
1723 SWIGINTERN char *DirectTCPConnection_close(DirectTCPConnection *self){
1724             return directtcp_connection_close(self);
1725         }
1726
1727 SWIGINTERNINLINE SV *
1728 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1729 {
1730   SV *obj = sv_newmortal();
1731   if (carray) {
1732     sv_setpvn(obj, carray, size);
1733   } else {
1734     sv_setsv(obj, &PL_sv_undef);
1735   }
1736   return obj;
1737 }
1738
1739
1740 SWIGINTERNINLINE SV *
1741 SWIG_FromCharPtr(const char *cptr)
1742 {
1743   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1744 }
1745
1746
1747 SWIGINTERN swig_type_info*
1748 SWIG_pchar_descriptor(void)
1749 {
1750   static int init = 0;
1751   static swig_type_info* info = 0;
1752   if (!init) {
1753     info = SWIG_TypeQuery("_p_char");
1754     init = 1;
1755   }
1756   return info;
1757 }
1758
1759
1760 SWIGINTERN int
1761 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1762 {
1763   if (SvMAGICAL(obj)) {
1764      SV *tmp = sv_newmortal();
1765      SvSetSV(tmp, obj);
1766      obj = tmp;
1767   }
1768   if (SvPOK(obj)) {
1769     STRLEN len = 0;
1770     char *cstr = SvPV(obj, len);
1771     size_t size = len + 1;
1772     if (cptr)  {
1773       if (alloc) {
1774         if (*alloc == SWIG_NEWOBJ) {
1775           *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1776         } else {
1777           *cptr = cstr;
1778           *alloc = SWIG_OLDOBJ;
1779         }
1780       }
1781     }
1782     if (psize) *psize = size;
1783     return SWIG_OK;
1784   } else {
1785     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1786     if (pchar_descriptor) {
1787       char* vptr = 0;
1788       if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1789         if (cptr) *cptr = vptr;
1790         if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1791         if (alloc) *alloc = SWIG_OLDOBJ;
1792         return SWIG_OK;
1793       }
1794     }
1795   }
1796   return SWIG_TypeError;
1797 }
1798
1799
1800
1801
1802 SWIGINTERN Device *new_Device(char *device_name){
1803             return device_open(device_name);
1804         }
1805 SWIGINTERN void delete_Device(Device *self){
1806             g_object_unref(self);
1807         }
1808
1809 #include <limits.h>
1810 #if !defined(SWIG_NO_LLONG_MAX)
1811 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1812 #   define LLONG_MAX __LONG_LONG_MAX__
1813 #   define LLONG_MIN (-LLONG_MAX - 1LL)
1814 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1815 # endif
1816 #endif
1817
1818
1819 SWIGINTERN int
1820 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1821 {
1822   if (SvNIOK(obj)) {
1823     if (val) *val = SvNV(obj);
1824     return SWIG_OK;
1825   } else if (SvIOK(obj)) {
1826     if (val) *val = (double) SvIV(obj);
1827     return SWIG_AddCast(SWIG_OK);
1828   } else {
1829     const char *nptr = SvPV_nolen(obj);
1830     if (nptr) {
1831       char *endptr;
1832       double v = strtod(nptr, &endptr);
1833       if (errno == ERANGE) {
1834         errno = 0;
1835         return SWIG_OverflowError;
1836       } else {
1837         if (*endptr == '\0') {
1838           if (val) *val = v;
1839           return SWIG_Str2NumCast(SWIG_OK);
1840         }
1841       }
1842     }
1843   }
1844   return SWIG_TypeError;
1845 }
1846
1847
1848 #include <float.h>
1849
1850
1851 #include <math.h>
1852
1853
1854 SWIGINTERNINLINE int
1855 SWIG_CanCastAsInteger(double *d, double min, double max) {
1856   double x = *d;
1857   if ((min <= x && x <= max)) {
1858    double fx = floor(x);
1859    double cx = ceil(x);
1860    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1861    if ((errno == EDOM) || (errno == ERANGE)) {
1862      errno = 0;
1863    } else {
1864      double summ, reps, diff;
1865      if (rd < x) {
1866        diff = x - rd;
1867      } else if (rd > x) {
1868        diff = rd - x;
1869      } else {
1870        return 1;
1871      }
1872      summ = rd + x;
1873      reps = diff/summ;
1874      if (reps < 8*DBL_EPSILON) {
1875        *d = rd;
1876        return 1;
1877      }
1878    }
1879   }
1880   return 0;
1881 }
1882
1883
1884 SWIGINTERN int
1885 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1886 {
1887   if (SvIOK(obj)) {
1888     if (val) *val = SvIV(obj);
1889     return SWIG_OK;
1890   } else {
1891     int dispatch = 0;
1892     const char *nptr = SvPV_nolen(obj);
1893     if (nptr) {
1894       char *endptr;
1895       long v;
1896       errno = 0;
1897       v = strtol(nptr, &endptr,0);
1898       if (errno == ERANGE) {
1899         errno = 0;
1900         return SWIG_OverflowError;
1901       } else {
1902         if (*endptr == '\0') {
1903           if (val) *val = v;
1904           return SWIG_Str2NumCast(SWIG_OK);
1905         }
1906       }
1907     }
1908     if (!dispatch) {
1909       double d;
1910       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1911       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1912         if (val) *val = (long)(d);
1913         return res;
1914       }
1915     }
1916   }
1917   return SWIG_TypeError;
1918 }
1919
1920
1921 SWIGINTERN int
1922 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1923 {
1924   long v;
1925   int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1926   if (SWIG_IsOK(res)) {
1927     if ((v < INT_MIN || v > INT_MAX)) {
1928       return SWIG_OverflowError;
1929     } else {
1930       if (val) *val = (int)(v);
1931     }
1932   }
1933   return res;
1934 }
1935
1936 SWIGINTERN gboolean Device_configure(Device *self,gboolean use_global_config){
1937             return device_configure(self, use_global_config);
1938         }
1939 SWIGINTERN char *Device_error(Device *self){
1940             return device_error(self);
1941         }
1942 SWIGINTERN char *Device_status_error(Device *self){
1943             return device_status_error(self);
1944         }
1945 SWIGINTERN char *Device_error_or_status(Device *self){
1946             return device_error_or_status(self);
1947         }
1948 SWIGINTERN DeviceStatusFlags Device_read_label(Device *self){
1949             return device_read_label(self);
1950         }
1951 SWIGINTERN gboolean Device_start(Device *self,DeviceAccessMode mode,char *label,char *timestamp){
1952             return device_start(self, mode, label, timestamp);
1953         }
1954 SWIGINTERN gboolean Device_finish(Device *self){
1955             return device_finish(self);
1956         }
1957 SWIGINTERN gboolean Device_start_file(Device *self,dumpfile_t *jobInfo){
1958             return device_start_file(self, jobInfo);
1959         }
1960 SWIGINTERN gboolean Device_write_block(Device *self,guint size,gpointer data){
1961             return device_write_block(self, size, data);
1962         }
1963 SWIGINTERN gboolean Device_finish_file(Device *self){
1964             return device_finish_file(self);
1965         }
1966 SWIGINTERN dumpfile_t *Device_seek_file(Device *self,guint file){
1967             return device_seek_file(self, file);
1968         }
1969 SWIGINTERN gboolean Device_seek_block(Device *self,guint64 block){
1970             return device_seek_block(self, block);
1971         }
1972 SWIGINTERN int Device_read_block(Device *self,gpointer buffer,int *size){
1973             return device_read_block(self, buffer, size);
1974         }
1975 SWIGINTERN gboolean Device_erase(Device *self){
1976             return device_erase(self);
1977         }
1978 SWIGINTERN gboolean Device_eject(Device *self){
1979             return device_eject(self);
1980         }
1981 SWIGINTERN gboolean Device_directtcp_supported(Device *self){
1982             return device_directtcp_supported(self);
1983         }
1984 SWIGINTERN void Device_listen(Device *self,gboolean for_writing,DirectTCPAddr **addrs){
1985             /* ensure that the addresses are empty if there was an error */
1986             if (!device_listen(self, for_writing, addrs))
1987                 *addrs = NULL;
1988         }
1989 SWIGINTERN DirectTCPConnection *Device_accept(Device *self){
1990             DirectTCPConnection *conn = NULL;
1991             gboolean rv;
1992
1993             rv = device_accept(self, &conn, NULL, NULL);
1994             if (!rv && conn) {
1995                 /* conn is ref'd for our convenience, but we don't want it */
1996                 g_object_unref(conn);
1997                 conn = NULL;
1998             }
1999             return conn;
2000         }
2001 SWIGINTERN DirectTCPConnection *Device_connect(Device *self,gboolean for_writing,DirectTCPAddr *addrs){
2002             DirectTCPConnection *conn = NULL;
2003             gboolean rv;
2004
2005             rv = device_connect(self, for_writing, addrs, &conn, NULL, NULL);
2006             if (!rv && conn) {
2007                 /* conn is ref'd for our convenience, but we don't want it */
2008                 g_object_unref(conn);
2009                 conn = NULL;
2010             }
2011             return conn;
2012         }
2013 SWIGINTERN gboolean Device_use_connection(Device *self,DirectTCPConnection *conn){
2014             return device_use_connection(self, conn);
2015         }
2016 SWIGINTERN gboolean Device_write_from_connection(Device *self,guint64 size,guint64 *actual_size){
2017             return device_write_from_connection(self, size, actual_size);
2018         }
2019 SWIGINTERN gboolean Device_read_to_connection(Device *self,guint64 size,guint64 *actual_size){
2020             return device_read_to_connection(self, size, actual_size);
2021         }
2022 SWIGINTERN GSList const *Device_property_list(Device *self){
2023             return device_property_get_list(self);
2024         }
2025 SWIGINTERN void Device_property_get(Device *self,DevicePropertyBase *pbase,GValue *out_val,PropertySurety *surety,PropertySource *source,gboolean *val_found){
2026             if (pbase) {
2027                 *val_found = device_property_get_ex(self, pbase->ID, out_val, surety, source);
2028             } else {
2029                 *val_found = FALSE;
2030             }
2031         }
2032 SWIGINTERN gboolean Device_property_set(Device *self,DevicePropertyBase *pbase,SV *sv){
2033             GValue gval;
2034
2035             if (!pbase)
2036                 goto fail;
2037             memset(&gval, 0, sizeof(gval));
2038             g_value_init(&gval, pbase->type);
2039             if (!set_gvalue_from_sv(sv, &gval))
2040                 goto fail;
2041
2042             if (!device_property_set(self, pbase->ID, &gval))
2043                 goto fail;
2044
2045             g_value_unset(&gval);
2046             return TRUE;
2047         fail:
2048             g_value_unset(&gval);
2049             return FALSE;
2050         }
2051 SWIGINTERN gboolean Device_property_set_ex(Device *self,DevicePropertyBase *pbase,SV *sv,PropertySurety surety,PropertySource source){
2052             GValue gval;
2053             memset(&gval, 0, sizeof(gval));
2054             g_value_init(&gval, pbase->type);
2055             if (!set_gvalue_from_sv(sv, &gval))
2056                 goto fail;
2057
2058             if (!device_property_set_ex(self, pbase->ID, &gval, surety, source))
2059                 goto fail;
2060
2061             g_value_unset(&gval);
2062             return TRUE;
2063         fail:
2064             g_value_unset(&gval);
2065             return FALSE;
2066         }
2067 SWIGINTERN gboolean Device_recycle_file(Device *self,guint filenum){
2068             return device_recycle_file(self, filenum);
2069         }
2070 SWIGINTERN int Device_file(Device *self){ return self->file; }
2071 SWIGINTERN guint64 Device_block(Device *self){ return self->block; }
2072 SWIGINTERN gboolean Device_in_file(Device *self){ return self->in_file; }
2073 SWIGINTERN char *Device_device_name(Device *self){ return self->device_name; }
2074 SWIGINTERN DeviceAccessMode Device_access_mode(Device *self){ return self->access_mode; }
2075 SWIGINTERN gboolean Device_is_eof(Device *self){ return self->is_eof; }
2076 SWIGINTERN gboolean Device_is_eom(Device *self){ return self->is_eom; }
2077 SWIGINTERN char *Device_volume_label(Device *self){ return self->volume_label; }
2078 SWIGINTERN char *Device_volume_time(Device *self){ return self->volume_time; }
2079 SWIGINTERN DeviceStatusFlags Device_status(Device *self){ return self->status; }
2080 SWIGINTERN gsize Device_min_block_size(Device *self){ return self->min_block_size; }
2081 SWIGINTERN gsize Device_max_block_size(Device *self){ return self->max_block_size; }
2082 SWIGINTERN gsize Device_block_size(Device *self){ return self->block_size; }
2083 SWIGINTERN dumpfile_t *Device_volume_header(Device *self){ return self->volume_header; }
2084
2085
2086 /* write LENGTH bytes of random data to FILENAME, seeded with SEED */
2087 gboolean
2088 write_random_to_device(guint32 seed, size_t length, Device *device) {
2089     simpleprng_state_t prng;
2090     char *buf;
2091     gsize block_size = device->block_size;
2092     g_assert(block_size < G_MAXUINT);
2093
2094     buf = g_malloc(block_size);
2095     simpleprng_seed(&prng, seed);
2096
2097     while (length) {
2098         size_t to_write = min(block_size, length);
2099
2100         simpleprng_fill_buffer(&prng, buf, to_write);
2101         if (!device_write_block(device, (guint)block_size, buf)) {
2102             g_free(buf);
2103             return FALSE;
2104         }
2105         length -= to_write;
2106     }
2107
2108     g_free(buf);
2109     return TRUE;
2110 }
2111
2112 /* read LENGTH bytes of random data from FILENAME verifying it against
2113  * a PRNG seeded with SEED.  Sends any error messages to stderr.
2114  */
2115 gboolean
2116 verify_random_from_device(guint32 seed, size_t length, Device *device) {
2117     simpleprng_state_t prng;
2118     char *buf = NULL; /* first device_read_block will get the size */
2119     int block_size = 0;
2120
2121     simpleprng_seed(&prng, seed);
2122
2123     while (length) {
2124         int bytes_read;
2125         int size = block_size;
2126
2127         bytes_read = device_read_block(device, buf, &size);
2128         if (bytes_read == 0 && size > block_size) {
2129             g_free(buf);
2130             block_size = size;
2131             buf = g_malloc(block_size);
2132             continue;
2133         }
2134         if (bytes_read == -1) {
2135             if (device->status == DEVICE_STATUS_SUCCESS) {
2136                 g_assert(device->is_eof);
2137                 g_debug("verify_random_from_device got unexpected EOF");
2138             }
2139             goto error;
2140         }
2141
2142         /* strip padding */
2143         bytes_read = min(bytes_read, length);
2144
2145         if (!simpleprng_verify_buffer(&prng, buf, bytes_read))
2146             goto error;
2147
2148         length -= bytes_read;
2149     }
2150
2151     g_free(buf);
2152     return TRUE;
2153
2154 error:
2155     g_free(buf);
2156     return FALSE;
2157 }
2158
2159
2160 SWIGINTERN int
2161 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
2162 {
2163   if (SvUOK(obj)) {
2164     if (val) *val = SvUV(obj);
2165     return SWIG_OK;
2166   } else  if (SvIOK(obj)) {
2167     long v = SvIV(obj);
2168     if (v >= 0) {
2169       if (val) *val = v;
2170       return SWIG_OK;
2171     } else {
2172       return SWIG_OverflowError;
2173     }
2174   } else {
2175     int dispatch = 0;
2176     const char *nptr = SvPV_nolen(obj);
2177     if (nptr) {
2178       char *endptr;
2179       unsigned long v;
2180       errno = 0;
2181       v = strtoul(nptr, &endptr,0);
2182       if (errno == ERANGE) {
2183         errno = 0;
2184         return SWIG_OverflowError;
2185       } else {
2186         if (*endptr == '\0') {
2187           if (val) *val = v;
2188           return SWIG_Str2NumCast(SWIG_OK);
2189         }
2190       }
2191     }
2192     if (!dispatch) {
2193       double d;
2194       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
2195       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2196         if (val) *val = (unsigned long)(d);
2197         return res;
2198       }
2199     }
2200   }
2201   return SWIG_TypeError;
2202 }
2203
2204
2205 SWIGINTERNINLINE int
2206 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
2207 {
2208   unsigned long v;
2209   int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
2210   if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2211   return res;
2212 }
2213
2214
2215 SWIGINTERNINLINE SV *
2216 SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
2217 {
2218   SV *obj = sv_newmortal();
2219   sv_setiv(obj, (IV) value);
2220   return obj;
2221 }
2222
2223
2224 SWIGINTERNINLINE SV *
2225 SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
2226 {
2227   return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
2228 }
2229
2230 #ifdef __cplusplus
2231 extern "C" {
2232 #endif
2233
2234 #ifdef PERL_OBJECT
2235 #define MAGIC_CLASS _wrap_Amanda__Device_var::
2236 class _wrap_Amanda__Device_var : public CPerlObj {
2237 public:
2238 #else
2239 #define MAGIC_CLASS
2240 #endif
2241 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
2242     MAGIC_PPERL
2243     croak("Value is read-only.");
2244     return 0;
2245 }
2246
2247
2248 #ifdef PERL_OBJECT
2249 };
2250 #endif
2251
2252 #ifdef __cplusplus
2253 }
2254 #endif
2255
2256 #ifdef __cplusplus
2257 extern "C" {
2258 #endif
2259 XS(_wrap_delete_DirectTCPConnection) {
2260   {
2261     DirectTCPConnection *arg1 = (DirectTCPConnection *) 0 ;
2262     void *argp1 = 0 ;
2263     int res1 = 0 ;
2264     int argvi = 0;
2265     dXSARGS;
2266
2267     if ((items < 1) || (items > 1)) {
2268       SWIG_croak("Usage: delete_DirectTCPConnection(self);");
2269     }
2270     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_DirectTCPConnection, SWIG_POINTER_DISOWN |  0 );
2271     if (!SWIG_IsOK(res1)) {
2272       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DirectTCPConnection" "', argument " "1"" of type '" "DirectTCPConnection *""'");
2273     }
2274     arg1 = (DirectTCPConnection *)(argp1);
2275     delete_DirectTCPConnection(arg1);
2276     ST(argvi) = sv_newmortal();
2277
2278     XSRETURN(argvi);
2279   fail:
2280
2281     SWIG_croak_null();
2282   }
2283 }
2284
2285
2286 XS(_wrap_DirectTCPConnection_close) {
2287   {
2288     DirectTCPConnection *arg1 = (DirectTCPConnection *) 0 ;
2289     void *argp1 = 0 ;
2290     int res1 = 0 ;
2291     int argvi = 0;
2292     char *result = 0 ;
2293     dXSARGS;
2294
2295     if ((items < 1) || (items > 1)) {
2296       SWIG_croak("Usage: DirectTCPConnection_close(self);");
2297     }
2298     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_DirectTCPConnection, 0 |  0 );
2299     if (!SWIG_IsOK(res1)) {
2300       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirectTCPConnection_close" "', argument " "1"" of type '" "DirectTCPConnection *""'");
2301     }
2302     arg1 = (DirectTCPConnection *)(argp1);
2303     result = (char *)DirectTCPConnection_close(arg1);
2304     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2305
2306     free((char*)result);
2307     XSRETURN(argvi);
2308   fail:
2309
2310     SWIG_croak_null();
2311   }
2312 }
2313
2314
2315 XS(_wrap_new_DirectTCPConnection) {
2316   {
2317     int argvi = 0;
2318     DirectTCPConnection *result = 0 ;
2319     dXSARGS;
2320
2321     if ((items < 0) || (items > 0)) {
2322       SWIG_croak("Usage: new_DirectTCPConnection();");
2323     }
2324     result = (DirectTCPConnection *)calloc(1, sizeof(DirectTCPConnection));
2325     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirectTCPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
2326     XSRETURN(argvi);
2327   fail:
2328     SWIG_croak_null();
2329   }
2330 }
2331
2332
2333 XS(_wrap_unaliased_name) {
2334   {
2335     char *arg1 = (char *) 0 ;
2336     int res1 ;
2337     char *buf1 = 0 ;
2338     int alloc1 = 0 ;
2339     int argvi = 0;
2340     char *result = 0 ;
2341     dXSARGS;
2342
2343     if ((items < 1) || (items > 1)) {
2344       SWIG_croak("Usage: unaliased_name(char *);");
2345     }
2346     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2347     if (!SWIG_IsOK(res1)) {
2348       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unaliased_name" "', argument " "1"" of type '" "char *""'");
2349     }
2350     arg1 = (char *)(buf1);
2351     result = (char *)device_unaliased_name(arg1);
2352     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2353     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2354     XSRETURN(argvi);
2355   fail:
2356     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2357     SWIG_croak_null();
2358   }
2359 }
2360
2361
2362 XS(_wrap_new_Device) {
2363   {
2364     char *arg1 = (char *) 0 ;
2365     int res1 ;
2366     char *buf1 = 0 ;
2367     int alloc1 = 0 ;
2368     int argvi = 0;
2369     Device *result = 0 ;
2370     dXSARGS;
2371
2372     if ((items < 1) || (items > 1)) {
2373       SWIG_croak("Usage: new_Device(device_name);");
2374     }
2375     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2376     if (!SWIG_IsOK(res1)) {
2377       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Device" "', argument " "1"" of type '" "char *""'");
2378     }
2379     arg1 = (char *)(buf1);
2380     result = (Device *)new_Device(arg1);
2381     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Device, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
2382     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2383     XSRETURN(argvi);
2384   fail:
2385     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2386     SWIG_croak_null();
2387   }
2388 }
2389
2390
2391 XS(_wrap_delete_Device) {
2392   {
2393     Device *arg1 = (Device *) 0 ;
2394     void *argp1 = 0 ;
2395     int res1 = 0 ;
2396     int argvi = 0;
2397     dXSARGS;
2398
2399     if ((items < 1) || (items > 1)) {
2400       SWIG_croak("Usage: delete_Device(self);");
2401     }
2402     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, SWIG_POINTER_DISOWN |  0 );
2403     if (!SWIG_IsOK(res1)) {
2404       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Device" "', argument " "1"" of type '" "Device *""'");
2405     }
2406     arg1 = (Device *)(argp1);
2407     delete_Device(arg1);
2408     ST(argvi) = sv_newmortal();
2409
2410     XSRETURN(argvi);
2411   fail:
2412
2413     SWIG_croak_null();
2414   }
2415 }
2416
2417
2418 XS(_wrap_Device_configure) {
2419   {
2420     Device *arg1 = (Device *) 0 ;
2421     gboolean arg2 ;
2422     void *argp1 = 0 ;
2423     int res1 = 0 ;
2424     int argvi = 0;
2425     gboolean result;
2426     dXSARGS;
2427
2428     if ((items < 2) || (items > 2)) {
2429       SWIG_croak("Usage: Device_configure(self,use_global_config);");
2430     }
2431     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2432     if (!SWIG_IsOK(res1)) {
2433       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_configure" "', argument " "1"" of type '" "Device *""'");
2434     }
2435     arg1 = (Device *)(argp1);
2436     {
2437       arg2 = SvTRUE(ST(1));
2438     }
2439     result = (gboolean)Device_configure(arg1,arg2);
2440     {
2441       if (result)
2442       ST(argvi) = &PL_sv_yes;
2443       else
2444       ST(argvi) = &PL_sv_no;
2445       argvi++;
2446     }
2447
2448
2449     XSRETURN(argvi);
2450   fail:
2451
2452
2453     SWIG_croak_null();
2454   }
2455 }
2456
2457
2458 XS(_wrap_Device_error) {
2459   {
2460     Device *arg1 = (Device *) 0 ;
2461     void *argp1 = 0 ;
2462     int res1 = 0 ;
2463     int argvi = 0;
2464     char *result = 0 ;
2465     dXSARGS;
2466
2467     if ((items < 1) || (items > 1)) {
2468       SWIG_croak("Usage: Device_error(self);");
2469     }
2470     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2471     if (!SWIG_IsOK(res1)) {
2472       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_error" "', argument " "1"" of type '" "Device *""'");
2473     }
2474     arg1 = (Device *)(argp1);
2475     result = (char *)Device_error(arg1);
2476     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2477
2478     XSRETURN(argvi);
2479   fail:
2480
2481     SWIG_croak_null();
2482   }
2483 }
2484
2485
2486 XS(_wrap_Device_status_error) {
2487   {
2488     Device *arg1 = (Device *) 0 ;
2489     void *argp1 = 0 ;
2490     int res1 = 0 ;
2491     int argvi = 0;
2492     char *result = 0 ;
2493     dXSARGS;
2494
2495     if ((items < 1) || (items > 1)) {
2496       SWIG_croak("Usage: Device_status_error(self);");
2497     }
2498     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2499     if (!SWIG_IsOK(res1)) {
2500       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_status_error" "', argument " "1"" of type '" "Device *""'");
2501     }
2502     arg1 = (Device *)(argp1);
2503     result = (char *)Device_status_error(arg1);
2504     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2505
2506     XSRETURN(argvi);
2507   fail:
2508
2509     SWIG_croak_null();
2510   }
2511 }
2512
2513
2514 XS(_wrap_Device_error_or_status) {
2515   {
2516     Device *arg1 = (Device *) 0 ;
2517     void *argp1 = 0 ;
2518     int res1 = 0 ;
2519     int argvi = 0;
2520     char *result = 0 ;
2521     dXSARGS;
2522
2523     if ((items < 1) || (items > 1)) {
2524       SWIG_croak("Usage: Device_error_or_status(self);");
2525     }
2526     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2527     if (!SWIG_IsOK(res1)) {
2528       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_error_or_status" "', argument " "1"" of type '" "Device *""'");
2529     }
2530     arg1 = (Device *)(argp1);
2531     result = (char *)Device_error_or_status(arg1);
2532     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2533
2534     XSRETURN(argvi);
2535   fail:
2536
2537     SWIG_croak_null();
2538   }
2539 }
2540
2541
2542 XS(_wrap_Device_read_label) {
2543   {
2544     Device *arg1 = (Device *) 0 ;
2545     void *argp1 = 0 ;
2546     int res1 = 0 ;
2547     int argvi = 0;
2548     DeviceStatusFlags result;
2549     dXSARGS;
2550
2551     if ((items < 1) || (items > 1)) {
2552       SWIG_croak("Usage: Device_read_label(self);");
2553     }
2554     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2555     if (!SWIG_IsOK(res1)) {
2556       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_label" "', argument " "1"" of type '" "Device *""'");
2557     }
2558     arg1 = (Device *)(argp1);
2559     result = (DeviceStatusFlags)Device_read_label(arg1);
2560     {
2561       SV *for_stack;
2562       SP += argvi; PUTBACK;
2563       for_stack = sv_2mortal(amglue_newSVi64(result));
2564       SPAGAIN; SP -= argvi;
2565       ST(argvi) = for_stack;
2566       argvi++;
2567     }
2568
2569     XSRETURN(argvi);
2570   fail:
2571
2572     SWIG_croak_null();
2573   }
2574 }
2575
2576
2577 XS(_wrap_Device_start) {
2578   {
2579     Device *arg1 = (Device *) 0 ;
2580     DeviceAccessMode arg2 ;
2581     char *arg3 = (char *) 0 ;
2582     char *arg4 = (char *) 0 ;
2583     void *argp1 = 0 ;
2584     int res1 = 0 ;
2585     int res3 ;
2586     char *buf3 = 0 ;
2587     int alloc3 = 0 ;
2588     int res4 ;
2589     char *buf4 = 0 ;
2590     int alloc4 = 0 ;
2591     int argvi = 0;
2592     gboolean result;
2593     dXSARGS;
2594
2595     if ((items < 4) || (items > 4)) {
2596       SWIG_croak("Usage: Device_start(self,mode,label,timestamp);");
2597     }
2598     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2599     if (!SWIG_IsOK(res1)) {
2600       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_start" "', argument " "1"" of type '" "Device *""'");
2601     }
2602     arg1 = (Device *)(argp1);
2603     {
2604       if (sizeof(signed int) == 1) {
2605         arg2 = amglue_SvI8(ST(1));
2606       } else if (sizeof(signed int) == 2) {
2607         arg2 = amglue_SvI16(ST(1));
2608       } else if (sizeof(signed int) == 4) {
2609         arg2 = amglue_SvI32(ST(1));
2610       } else if (sizeof(signed int) == 8) {
2611         arg2 = amglue_SvI64(ST(1));
2612       } else {
2613         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2614       }
2615     }
2616     res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2617     if (!SWIG_IsOK(res3)) {
2618       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_start" "', argument " "3"" of type '" "char *""'");
2619     }
2620     arg3 = (char *)(buf3);
2621     res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
2622     if (!SWIG_IsOK(res4)) {
2623       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Device_start" "', argument " "4"" of type '" "char *""'");
2624     }
2625     arg4 = (char *)(buf4);
2626     result = (gboolean)Device_start(arg1,arg2,arg3,arg4);
2627     {
2628       if (result)
2629       ST(argvi) = &PL_sv_yes;
2630       else
2631       ST(argvi) = &PL_sv_no;
2632       argvi++;
2633     }
2634
2635
2636     if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2637     if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2638     XSRETURN(argvi);
2639   fail:
2640
2641
2642     if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2643     if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2644     SWIG_croak_null();
2645   }
2646 }
2647
2648
2649 XS(_wrap_Device_finish) {
2650   {
2651     Device *arg1 = (Device *) 0 ;
2652     void *argp1 = 0 ;
2653     int res1 = 0 ;
2654     int argvi = 0;
2655     gboolean result;
2656     dXSARGS;
2657
2658     if ((items < 1) || (items > 1)) {
2659       SWIG_croak("Usage: Device_finish(self);");
2660     }
2661     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2662     if (!SWIG_IsOK(res1)) {
2663       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_finish" "', argument " "1"" of type '" "Device *""'");
2664     }
2665     arg1 = (Device *)(argp1);
2666     result = (gboolean)Device_finish(arg1);
2667     {
2668       if (result)
2669       ST(argvi) = &PL_sv_yes;
2670       else
2671       ST(argvi) = &PL_sv_no;
2672       argvi++;
2673     }
2674
2675     XSRETURN(argvi);
2676   fail:
2677
2678     SWIG_croak_null();
2679   }
2680 }
2681
2682
2683 XS(_wrap_Device_start_file) {
2684   {
2685     Device *arg1 = (Device *) 0 ;
2686     dumpfile_t *arg2 = (dumpfile_t *) 0 ;
2687     void *argp1 = 0 ;
2688     int res1 = 0 ;
2689     void *argp2 = 0 ;
2690     int res2 = 0 ;
2691     int argvi = 0;
2692     gboolean result;
2693     dXSARGS;
2694
2695     if ((items < 2) || (items > 2)) {
2696       SWIG_croak("Usage: Device_start_file(self,jobInfo);");
2697     }
2698     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2699     if (!SWIG_IsOK(res1)) {
2700       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_start_file" "', argument " "1"" of type '" "Device *""'");
2701     }
2702     arg1 = (Device *)(argp1);
2703     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2704     if (!SWIG_IsOK(res2)) {
2705       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_start_file" "', argument " "2"" of type '" "dumpfile_t *""'");
2706     }
2707     arg2 = (dumpfile_t *)(argp2);
2708     result = (gboolean)Device_start_file(arg1,arg2);
2709     {
2710       if (result)
2711       ST(argvi) = &PL_sv_yes;
2712       else
2713       ST(argvi) = &PL_sv_no;
2714       argvi++;
2715     }
2716
2717
2718     XSRETURN(argvi);
2719   fail:
2720
2721
2722     SWIG_croak_null();
2723   }
2724 }
2725
2726
2727 XS(_wrap_Device_write_block) {
2728   {
2729     Device *arg1 = (Device *) 0 ;
2730     guint arg2 ;
2731     gpointer arg3 = (gpointer) 0 ;
2732     void *argp1 = 0 ;
2733     int res1 = 0 ;
2734     int res3 ;
2735     int argvi = 0;
2736     gboolean result;
2737     dXSARGS;
2738
2739     if ((items < 3) || (items > 3)) {
2740       SWIG_croak("Usage: Device_write_block(self,size,data);");
2741     }
2742     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2743     if (!SWIG_IsOK(res1)) {
2744       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_block" "', argument " "1"" of type '" "Device *""'");
2745     }
2746     arg1 = (Device *)(argp1);
2747     {
2748       if (sizeof(guint) == 1) {
2749         arg2 = amglue_SvU8(ST(1));
2750       } else if (sizeof(guint) == 2) {
2751         arg2 = amglue_SvU16(ST(1));
2752       } else if (sizeof(guint) == 4) {
2753         arg2 = amglue_SvU32(ST(1));
2754       } else if (sizeof(guint) == 8) {
2755         arg2 = amglue_SvU64(ST(1));
2756       } else {
2757         croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
2758       }
2759     }
2760     res3 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg3), 0, 0);
2761     if (!SWIG_IsOK(res3)) {
2762       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_write_block" "', argument " "3"" of type '" "gpointer""'");
2763     }
2764     result = (gboolean)Device_write_block(arg1,arg2,arg3);
2765     {
2766       if (result)
2767       ST(argvi) = &PL_sv_yes;
2768       else
2769       ST(argvi) = &PL_sv_no;
2770       argvi++;
2771     }
2772
2773
2774     XSRETURN(argvi);
2775   fail:
2776
2777
2778     SWIG_croak_null();
2779   }
2780 }
2781
2782
2783 XS(_wrap_Device_finish_file) {
2784   {
2785     Device *arg1 = (Device *) 0 ;
2786     void *argp1 = 0 ;
2787     int res1 = 0 ;
2788     int argvi = 0;
2789     gboolean result;
2790     dXSARGS;
2791
2792     if ((items < 1) || (items > 1)) {
2793       SWIG_croak("Usage: Device_finish_file(self);");
2794     }
2795     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2796     if (!SWIG_IsOK(res1)) {
2797       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_finish_file" "', argument " "1"" of type '" "Device *""'");
2798     }
2799     arg1 = (Device *)(argp1);
2800     result = (gboolean)Device_finish_file(arg1);
2801     {
2802       if (result)
2803       ST(argvi) = &PL_sv_yes;
2804       else
2805       ST(argvi) = &PL_sv_no;
2806       argvi++;
2807     }
2808
2809     XSRETURN(argvi);
2810   fail:
2811
2812     SWIG_croak_null();
2813   }
2814 }
2815
2816
2817 XS(_wrap_Device_seek_file) {
2818   {
2819     Device *arg1 = (Device *) 0 ;
2820     guint arg2 ;
2821     void *argp1 = 0 ;
2822     int res1 = 0 ;
2823     int argvi = 0;
2824     dumpfile_t *result = 0 ;
2825     dXSARGS;
2826
2827     if ((items < 2) || (items > 2)) {
2828       SWIG_croak("Usage: Device_seek_file(self,file);");
2829     }
2830     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2831     if (!SWIG_IsOK(res1)) {
2832       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_seek_file" "', argument " "1"" of type '" "Device *""'");
2833     }
2834     arg1 = (Device *)(argp1);
2835     {
2836       if (sizeof(guint) == 1) {
2837         arg2 = amglue_SvU8(ST(1));
2838       } else if (sizeof(guint) == 2) {
2839         arg2 = amglue_SvU16(ST(1));
2840       } else if (sizeof(guint) == 4) {
2841         arg2 = amglue_SvU32(ST(1));
2842       } else if (sizeof(guint) == 8) {
2843         arg2 = amglue_SvU64(ST(1));
2844       } else {
2845         croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
2846       }
2847     }
2848     result = (dumpfile_t *)Device_seek_file(arg1,arg2);
2849     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, 0 | SWIG_SHADOW); argvi++ ;
2850
2851     XSRETURN(argvi);
2852   fail:
2853
2854     SWIG_croak_null();
2855   }
2856 }
2857
2858
2859 XS(_wrap_Device_seek_block) {
2860   {
2861     Device *arg1 = (Device *) 0 ;
2862     guint64 arg2 ;
2863     void *argp1 = 0 ;
2864     int res1 = 0 ;
2865     int argvi = 0;
2866     gboolean result;
2867     dXSARGS;
2868
2869     if ((items < 2) || (items > 2)) {
2870       SWIG_croak("Usage: Device_seek_block(self,block);");
2871     }
2872     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2873     if (!SWIG_IsOK(res1)) {
2874       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_seek_block" "', argument " "1"" of type '" "Device *""'");
2875     }
2876     arg1 = (Device *)(argp1);
2877     {
2878       arg2 = amglue_SvU64(ST(1));
2879     }
2880     result = (gboolean)Device_seek_block(arg1,arg2);
2881     {
2882       if (result)
2883       ST(argvi) = &PL_sv_yes;
2884       else
2885       ST(argvi) = &PL_sv_no;
2886       argvi++;
2887     }
2888
2889     XSRETURN(argvi);
2890   fail:
2891
2892     SWIG_croak_null();
2893   }
2894 }
2895
2896
2897 XS(_wrap_Device_read_block) {
2898   {
2899     Device *arg1 = (Device *) 0 ;
2900     gpointer arg2 = (gpointer) 0 ;
2901     int *arg3 = (int *) 0 ;
2902     void *argp1 = 0 ;
2903     int res1 = 0 ;
2904     int res2 ;
2905     void *argp3 = 0 ;
2906     int res3 = 0 ;
2907     int argvi = 0;
2908     int result;
2909     dXSARGS;
2910
2911     if ((items < 3) || (items > 3)) {
2912       SWIG_croak("Usage: Device_read_block(self,buffer,size);");
2913     }
2914     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2915     if (!SWIG_IsOK(res1)) {
2916       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_block" "', argument " "1"" of type '" "Device *""'");
2917     }
2918     arg1 = (Device *)(argp1);
2919     res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, 0);
2920     if (!SWIG_IsOK(res2)) {
2921       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_read_block" "', argument " "2"" of type '" "gpointer""'");
2922     }
2923     res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_int, 0 |  0 );
2924     if (!SWIG_IsOK(res3)) {
2925       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_read_block" "', argument " "3"" of type '" "int *""'");
2926     }
2927     arg3 = (int *)(argp3);
2928     result = (int)Device_read_block(arg1,arg2,arg3);
2929     {
2930       SV *for_stack;
2931       SP += argvi; PUTBACK;
2932       for_stack = sv_2mortal(amglue_newSVi64(result));
2933       SPAGAIN; SP -= argvi;
2934       ST(argvi) = for_stack;
2935       argvi++;
2936     }
2937
2938
2939
2940     XSRETURN(argvi);
2941   fail:
2942
2943
2944
2945     SWIG_croak_null();
2946   }
2947 }
2948
2949
2950 XS(_wrap_Device_erase) {
2951   {
2952     Device *arg1 = (Device *) 0 ;
2953     void *argp1 = 0 ;
2954     int res1 = 0 ;
2955     int argvi = 0;
2956     gboolean result;
2957     dXSARGS;
2958
2959     if ((items < 1) || (items > 1)) {
2960       SWIG_croak("Usage: Device_erase(self);");
2961     }
2962     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2963     if (!SWIG_IsOK(res1)) {
2964       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_erase" "', argument " "1"" of type '" "Device *""'");
2965     }
2966     arg1 = (Device *)(argp1);
2967     result = (gboolean)Device_erase(arg1);
2968     {
2969       if (result)
2970       ST(argvi) = &PL_sv_yes;
2971       else
2972       ST(argvi) = &PL_sv_no;
2973       argvi++;
2974     }
2975
2976     XSRETURN(argvi);
2977   fail:
2978
2979     SWIG_croak_null();
2980   }
2981 }
2982
2983
2984 XS(_wrap_Device_eject) {
2985   {
2986     Device *arg1 = (Device *) 0 ;
2987     void *argp1 = 0 ;
2988     int res1 = 0 ;
2989     int argvi = 0;
2990     gboolean result;
2991     dXSARGS;
2992
2993     if ((items < 1) || (items > 1)) {
2994       SWIG_croak("Usage: Device_eject(self);");
2995     }
2996     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2997     if (!SWIG_IsOK(res1)) {
2998       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_eject" "', argument " "1"" of type '" "Device *""'");
2999     }
3000     arg1 = (Device *)(argp1);
3001     result = (gboolean)Device_eject(arg1);
3002     {
3003       if (result)
3004       ST(argvi) = &PL_sv_yes;
3005       else
3006       ST(argvi) = &PL_sv_no;
3007       argvi++;
3008     }
3009
3010     XSRETURN(argvi);
3011   fail:
3012
3013     SWIG_croak_null();
3014   }
3015 }
3016
3017
3018 XS(_wrap_Device_directtcp_supported) {
3019   {
3020     Device *arg1 = (Device *) 0 ;
3021     void *argp1 = 0 ;
3022     int res1 = 0 ;
3023     int argvi = 0;
3024     gboolean result;
3025     dXSARGS;
3026
3027     if ((items < 1) || (items > 1)) {
3028       SWIG_croak("Usage: Device_directtcp_supported(self);");
3029     }
3030     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3031     if (!SWIG_IsOK(res1)) {
3032       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_directtcp_supported" "', argument " "1"" of type '" "Device *""'");
3033     }
3034     arg1 = (Device *)(argp1);
3035     result = (gboolean)Device_directtcp_supported(arg1);
3036     {
3037       if (result)
3038       ST(argvi) = &PL_sv_yes;
3039       else
3040       ST(argvi) = &PL_sv_no;
3041       argvi++;
3042     }
3043
3044     XSRETURN(argvi);
3045   fail:
3046
3047     SWIG_croak_null();
3048   }
3049 }
3050
3051
3052 XS(_wrap_Device_listen) {
3053   {
3054     Device *arg1 = (Device *) 0 ;
3055     gboolean arg2 ;
3056     DirectTCPAddr **arg3 = (DirectTCPAddr **) 0 ;
3057     void *argp1 = 0 ;
3058     int res1 = 0 ;
3059     DirectTCPAddr *addrs3 ;
3060     int argvi = 0;
3061     dXSARGS;
3062
3063     {
3064       addrs3 = NULL;
3065       arg3 = &addrs3;
3066     }
3067     if ((items < 2) || (items > 2)) {
3068       SWIG_croak("Usage: Device_listen(self,for_writing);");
3069     }
3070     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3071     if (!SWIG_IsOK(res1)) {
3072       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_listen" "', argument " "1"" of type '" "Device *""'");
3073     }
3074     arg1 = (Device *)(argp1);
3075     {
3076       arg2 = SvTRUE(ST(1));
3077     }
3078     Device_listen(arg1,arg2,arg3);
3079     ST(argvi) = sv_newmortal();
3080     {
3081       if (arg3 && *arg3) {
3082         DirectTCPAddr *iter = *arg3;
3083         AV *av = newAV();
3084         int i = 0;
3085
3086         while (iter && SU_GET_FAMILY(iter) != 0) {
3087           char *addr = str_sockaddr_no_port(iter);
3088           AV *tuple = newAV();
3089
3090           g_assert(NULL != av_store(tuple, 0, newSVpv(addr, 0)));
3091           g_assert(NULL != av_store(tuple, 1, newSViv(SU_GET_PORT(iter))));
3092           g_assert(NULL != av_store(av, i++, newRV_noinc((SV *)tuple)));
3093           iter++;
3094         }
3095
3096         ST(argvi) = newRV_noinc((SV *)av);
3097         argvi++;
3098       }
3099     }
3100
3101
3102
3103     XSRETURN(argvi);
3104   fail:
3105
3106
3107
3108     SWIG_croak_null();
3109   }
3110 }
3111
3112
3113 XS(_wrap_Device_accept) {
3114   {
3115     Device *arg1 = (Device *) 0 ;
3116     void *argp1 = 0 ;
3117     int res1 = 0 ;
3118     int argvi = 0;
3119     DirectTCPConnection *result = 0 ;
3120     dXSARGS;
3121
3122     if ((items < 1) || (items > 1)) {
3123       SWIG_croak("Usage: Device_accept(self);");
3124     }
3125     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3126     if (!SWIG_IsOK(res1)) {
3127       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_accept" "', argument " "1"" of type '" "Device *""'");
3128     }
3129     arg1 = (Device *)(argp1);
3130     result = (DirectTCPConnection *)Device_accept(arg1);
3131     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirectTCPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3132
3133     XSRETURN(argvi);
3134   fail:
3135
3136     SWIG_croak_null();
3137   }
3138 }
3139
3140
3141 XS(_wrap_Device_connect) {
3142   {
3143     Device *arg1 = (Device *) 0 ;
3144     gboolean arg2 ;
3145     DirectTCPAddr *arg3 = (DirectTCPAddr *) 0 ;
3146     void *argp1 = 0 ;
3147     int res1 = 0 ;
3148     int argvi = 0;
3149     DirectTCPConnection *result = 0 ;
3150     dXSARGS;
3151
3152     if ((items < 3) || (items > 3)) {
3153       SWIG_croak("Usage: Device_connect(self,for_writing,addrs);");
3154     }
3155     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3156     if (!SWIG_IsOK(res1)) {
3157       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_connect" "', argument " "1"" of type '" "Device *""'");
3158     }
3159     arg1 = (Device *)(argp1);
3160     {
3161       arg2 = SvTRUE(ST(1));
3162     }
3163     {
3164       AV *addrs_av;
3165       int num_addrs, i;
3166
3167       if (!SvROK(ST(2)) || SvTYPE(SvRV(ST(2))) != SVt_PVAV) {
3168         SWIG_exception_fail(SWIG_TypeError, "must provide an arrayref of DirectTCPAddrs");
3169       }
3170       addrs_av = (AV *)SvRV(ST(2));
3171       num_addrs = av_len(addrs_av)+1;
3172
3173       arg3 = g_new0(DirectTCPAddr, num_addrs+1);
3174
3175       for (i = 0; i < num_addrs; i++) {
3176         SV **svp = av_fetch(addrs_av, i, 0);
3177         AV *addr_av;
3178         sockaddr_union addr;
3179         IV port;
3180
3181         if (!svp || !SvROK(*svp) || SvTYPE(SvRV(*svp)) != SVt_PVAV
3182           || av_len((AV *)SvRV(*svp))+1 != 2) {
3183           SWIG_exception_fail(SWIG_TypeError, "each DirectTCPAddr must be a 2-element arrayref");
3184         }
3185
3186         addr_av = (AV *)SvRV(*svp);
3187
3188         /* get address */
3189         svp = av_fetch(addr_av, 0, 0);
3190         if (!svp || !SvPOK(*svp) || !str_to_sockaddr(SvPV_nolen(*svp), &addr)) {
3191           SWIG_exception_fail(SWIG_TypeError, "invalid IPv4 addr in address");
3192         }
3193
3194         /* get port */
3195         svp = av_fetch(addr_av, 1, 0);
3196         if (!svp || !SvIOK(*svp) || (port = SvIV(*svp)) <= 0 || port >= 65536) {
3197           SWIG_exception_fail(SWIG_TypeError, "invalid port in address");
3198         }
3199         SU_SET_PORT(&addr, port);
3200
3201         copy_sockaddr(arg3, &addr);
3202       }
3203     }
3204     result = (DirectTCPConnection *)Device_connect(arg1,arg2,arg3);
3205     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirectTCPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3206
3207
3208
3209     XSRETURN(argvi);
3210   fail:
3211
3212
3213
3214     SWIG_croak_null();
3215   }
3216 }
3217
3218
3219 XS(_wrap_Device_use_connection) {
3220   {
3221     Device *arg1 = (Device *) 0 ;
3222     DirectTCPConnection *arg2 = (DirectTCPConnection *) 0 ;
3223     void *argp1 = 0 ;
3224     int res1 = 0 ;
3225     void *argp2 = 0 ;
3226     int res2 = 0 ;
3227     int argvi = 0;
3228     gboolean result;
3229     dXSARGS;
3230
3231     if ((items < 2) || (items > 2)) {
3232       SWIG_croak("Usage: Device_use_connection(self,conn);");
3233     }
3234     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3235     if (!SWIG_IsOK(res1)) {
3236       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_use_connection" "', argument " "1"" of type '" "Device *""'");
3237     }
3238     arg1 = (Device *)(argp1);
3239     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_DirectTCPConnection, 0 |  0 );
3240     if (!SWIG_IsOK(res2)) {
3241       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_use_connection" "', argument " "2"" of type '" "DirectTCPConnection *""'");
3242     }
3243     arg2 = (DirectTCPConnection *)(argp2);
3244     result = (gboolean)Device_use_connection(arg1,arg2);
3245     {
3246       if (result)
3247       ST(argvi) = &PL_sv_yes;
3248       else
3249       ST(argvi) = &PL_sv_no;
3250       argvi++;
3251     }
3252
3253
3254     XSRETURN(argvi);
3255   fail:
3256
3257
3258     SWIG_croak_null();
3259   }
3260 }
3261
3262
3263 XS(_wrap_Device_write_from_connection) {
3264   {
3265     Device *arg1 = (Device *) 0 ;
3266     guint64 arg2 ;
3267     guint64 *arg3 = (guint64 *) 0 ;
3268     void *argp1 = 0 ;
3269     int res1 = 0 ;
3270     guint64 sz3 ;
3271     int argvi = 0;
3272     gboolean result;
3273     dXSARGS;
3274
3275     {
3276       sz3 = 0;
3277       arg3 = &sz3;
3278     }
3279     if ((items < 2) || (items > 2)) {
3280       SWIG_croak("Usage: Device_write_from_connection(self,size);");
3281     }
3282     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3283     if (!SWIG_IsOK(res1)) {
3284       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_from_connection" "', argument " "1"" of type '" "Device *""'");
3285     }
3286     arg1 = (Device *)(argp1);
3287     {
3288       arg2 = amglue_SvU64(ST(1));
3289     }
3290     result = (gboolean)Device_write_from_connection(arg1,arg2,arg3);
3291     {
3292       if (result)
3293       ST(argvi) = &PL_sv_yes;
3294       else
3295       ST(argvi) = &PL_sv_no;
3296       argvi++;
3297     }
3298     {
3299       SP += argvi; PUTBACK;
3300       ST(argvi) = sv_2mortal(amglue_newSVu64(*arg3));
3301       SPAGAIN; SP -= argvi; argvi++;
3302     }
3303
3304
3305     XSRETURN(argvi);
3306   fail:
3307
3308
3309     SWIG_croak_null();
3310   }
3311 }
3312
3313
3314 XS(_wrap_Device_read_to_connection) {
3315   {
3316     Device *arg1 = (Device *) 0 ;
3317     guint64 arg2 ;
3318     guint64 *arg3 = (guint64 *) 0 ;
3319     void *argp1 = 0 ;
3320     int res1 = 0 ;
3321     guint64 sz3 ;
3322     int argvi = 0;
3323     gboolean result;
3324     dXSARGS;
3325
3326     {
3327       sz3 = 0;
3328       arg3 = &sz3;
3329     }
3330     if ((items < 2) || (items > 2)) {
3331       SWIG_croak("Usage: Device_read_to_connection(self,size);");
3332     }
3333     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3334     if (!SWIG_IsOK(res1)) {
3335       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_to_connection" "', argument " "1"" of type '" "Device *""'");
3336     }
3337     arg1 = (Device *)(argp1);
3338     {
3339       arg2 = amglue_SvU64(ST(1));
3340     }
3341     result = (gboolean)Device_read_to_connection(arg1,arg2,arg3);
3342     {
3343       if (result)
3344       ST(argvi) = &PL_sv_yes;
3345       else
3346       ST(argvi) = &PL_sv_no;
3347       argvi++;
3348     }
3349     {
3350       SP += argvi; PUTBACK;
3351       ST(argvi) = sv_2mortal(amglue_newSVu64(*arg3));
3352       SPAGAIN; SP -= argvi; argvi++;
3353     }
3354
3355
3356     XSRETURN(argvi);
3357   fail:
3358
3359
3360     SWIG_croak_null();
3361   }
3362 }
3363
3364
3365 XS(_wrap_Device_property_list) {
3366   {
3367     Device *arg1 = (Device *) 0 ;
3368     void *argp1 = 0 ;
3369     int res1 = 0 ;
3370     int argvi = 0;
3371     GSList *result = 0 ;
3372     dXSARGS;
3373
3374     if ((items < 1) || (items > 1)) {
3375       SWIG_croak("Usage: Device_property_list(self);");
3376     }
3377     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3378     if (!SWIG_IsOK(res1)) {
3379       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_list" "', argument " "1"" of type '" "Device *""'");
3380     }
3381     arg1 = (Device *)(argp1);
3382     result = (GSList *)Device_property_list(arg1);
3383     {
3384       GSList *iter;
3385
3386       /* Count the DeviceProperties */
3387       EXTEND(SP, g_slist_length(result)); /* make room for return values */
3388
3389       /* Note that we set ST(argvi) several times. the nature of
3390              * SWIG's wrapping is such that incrementing argvi points
3391              * ST(argvi) to the next location in perl's argument stack.
3392                    */
3393
3394       for (iter = result; iter; iter = g_slist_next(iter)) {
3395         DeviceProperty *prop = iter->data;
3396         HV *hash = newHV();
3397         SV *rv = newRV_noinc((SV *)hash);
3398
3399         hv_store(hash, "name", 4,
3400           newSVpv(prop->base->name, 0), 0);
3401         hv_store(hash, "description", 11,
3402           newSVpv(prop->base->description, 0), 0);
3403         hv_store(hash, "access", 6,
3404           newSViv(prop->access), 0);
3405         ST(argvi) = sv_2mortal(rv);
3406         argvi++;
3407       }
3408     }
3409
3410     XSRETURN(argvi);
3411   fail:
3412
3413     SWIG_croak_null();
3414   }
3415 }
3416
3417
3418 XS(_wrap_Device_property_get) {
3419   {
3420     Device *arg1 = (Device *) 0 ;
3421     DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
3422     GValue *arg3 = (GValue *) 0 ;
3423     PropertySurety *arg4 = (PropertySurety *) 0 ;
3424     PropertySource *arg5 = (PropertySource *) 0 ;
3425     gboolean *arg6 = (gboolean *) 0 ;
3426     void *argp1 = 0 ;
3427     int res1 = 0 ;
3428     GValue val3 ;
3429     PropertySurety surety3 ;
3430     PropertySource source3 ;
3431     gboolean found3 ;
3432     int argvi = 0;
3433     dXSARGS;
3434
3435     {
3436       memset(&val3, 0, sizeof(val3));
3437       arg3 = &val3;
3438       if (GIMME_V == G_ARRAY) {
3439         arg4 = &surety3;
3440         arg5 = &source3;
3441       }
3442       arg6 = &found3;
3443     }
3444     if ((items < 2) || (items > 2)) {
3445       SWIG_croak("Usage: Device_property_get(self,pbase,surety,source,val_found);");
3446     }
3447     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3448     if (!SWIG_IsOK(res1)) {
3449       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_get" "', argument " "1"" of type '" "Device *""'");
3450     }
3451     arg1 = (Device *)(argp1);
3452     {
3453       char *pname = NULL;
3454
3455       if (SvPOK(ST(1)))
3456       pname = SvPV_nolen(ST(1));
3457
3458       if (pname)
3459       arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
3460       else
3461       arg2 = NULL;
3462     }
3463     Device_property_get(arg1,arg2,arg3,arg4,arg5,arg6);
3464     ST(argvi) = sv_newmortal();
3465     {
3466       /* if the result is valid */
3467       if (*arg6) {
3468         /* move data from arg3 to ST(argvi), somehow, being careful to
3469                          * save the perl stack while doing so */
3470         SP += argvi; PUTBACK;
3471         ST(argvi) = set_sv_from_gvalue(arg3);
3472         SPAGAIN; SP -= argvi; argvi++;
3473
3474         /* free any memory for the GValue */
3475         g_value_unset(arg3);
3476
3477         if (GIMME_V == G_ARRAY) {
3478           ST(argvi) = newSViv(*arg4);
3479           argvi++;
3480           ST(argvi) = newSViv(*arg5);
3481           argvi++;
3482         }
3483       }
3484       /* otherwise, return nothing */
3485     }
3486
3487
3488     XSRETURN(argvi);
3489   fail:
3490
3491
3492     SWIG_croak_null();
3493   }
3494 }
3495
3496
3497 XS(_wrap_Device_property_set) {
3498   {
3499     Device *arg1 = (Device *) 0 ;
3500     DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
3501     SV *arg3 = (SV *) 0 ;
3502     void *argp1 = 0 ;
3503     int res1 = 0 ;
3504     int argvi = 0;
3505     gboolean result;
3506     dXSARGS;
3507
3508     if ((items < 3) || (items > 3)) {
3509       SWIG_croak("Usage: Device_property_set(self,pbase,sv);");
3510     }
3511     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3512     if (!SWIG_IsOK(res1)) {
3513       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_set" "', argument " "1"" of type '" "Device *""'");
3514     }
3515     arg1 = (Device *)(argp1);
3516     {
3517       char *pname = NULL;
3518
3519       if (SvPOK(ST(1)))
3520       pname = SvPV_nolen(ST(1));
3521
3522       if (pname)
3523       arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
3524       else
3525       arg2 = NULL;
3526     }
3527     arg3 = ST(2);
3528     result = (gboolean)Device_property_set(arg1,arg2,arg3);
3529     {
3530       if (result)
3531       ST(argvi) = &PL_sv_yes;
3532       else
3533       ST(argvi) = &PL_sv_no;
3534       argvi++;
3535     }
3536
3537
3538
3539     XSRETURN(argvi);
3540   fail:
3541
3542
3543
3544     SWIG_croak_null();
3545   }
3546 }
3547
3548
3549 XS(_wrap_Device_property_set_ex) {
3550   {
3551     Device *arg1 = (Device *) 0 ;
3552     DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
3553     SV *arg3 = (SV *) 0 ;
3554     PropertySurety arg4 ;
3555     PropertySource arg5 ;
3556     void *argp1 = 0 ;
3557     int res1 = 0 ;
3558     int argvi = 0;
3559     gboolean result;
3560     dXSARGS;
3561
3562     if ((items < 5) || (items > 5)) {
3563       SWIG_croak("Usage: Device_property_set_ex(self,pbase,sv,surety,source);");
3564     }
3565     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3566     if (!SWIG_IsOK(res1)) {
3567       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_set_ex" "', argument " "1"" of type '" "Device *""'");
3568     }
3569     arg1 = (Device *)(argp1);
3570     {
3571       char *pname = NULL;
3572
3573       if (SvPOK(ST(1)))
3574       pname = SvPV_nolen(ST(1));
3575
3576       if (pname)
3577       arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
3578       else
3579       arg2 = NULL;
3580     }
3581     arg3 = ST(2);
3582     {
3583       if (sizeof(signed int) == 1) {
3584         arg4 = amglue_SvI8(ST(3));
3585       } else if (sizeof(signed int) == 2) {
3586         arg4 = amglue_SvI16(ST(3));
3587       } else if (sizeof(signed int) == 4) {
3588         arg4 = amglue_SvI32(ST(3));
3589       } else if (sizeof(signed int) == 8) {
3590         arg4 = amglue_SvI64(ST(3));
3591       } else {
3592         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3593       }
3594     }
3595     {
3596       if (sizeof(signed int) == 1) {
3597         arg5 = amglue_SvI8(ST(4));
3598       } else if (sizeof(signed int) == 2) {
3599         arg5 = amglue_SvI16(ST(4));
3600       } else if (sizeof(signed int) == 4) {
3601         arg5 = amglue_SvI32(ST(4));
3602       } else if (sizeof(signed int) == 8) {
3603         arg5 = amglue_SvI64(ST(4));
3604       } else {
3605         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3606       }
3607     }
3608     result = (gboolean)Device_property_set_ex(arg1,arg2,arg3,arg4,arg5);
3609     {
3610       if (result)
3611       ST(argvi) = &PL_sv_yes;
3612       else
3613       ST(argvi) = &PL_sv_no;
3614       argvi++;
3615     }
3616
3617
3618
3619
3620
3621     XSRETURN(argvi);
3622   fail:
3623
3624
3625
3626
3627
3628     SWIG_croak_null();
3629   }
3630 }
3631
3632
3633 XS(_wrap_Device_recycle_file) {
3634   {
3635     Device *arg1 = (Device *) 0 ;
3636     guint arg2 ;
3637     void *argp1 = 0 ;
3638     int res1 = 0 ;
3639     int argvi = 0;
3640     gboolean result;
3641     dXSARGS;
3642
3643     if ((items < 2) || (items > 2)) {
3644       SWIG_croak("Usage: Device_recycle_file(self,filenum);");
3645     }
3646     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3647     if (!SWIG_IsOK(res1)) {
3648       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_recycle_file" "', argument " "1"" of type '" "Device *""'");
3649     }
3650     arg1 = (Device *)(argp1);
3651     {
3652       if (sizeof(guint) == 1) {
3653         arg2 = amglue_SvU8(ST(1));
3654       } else if (sizeof(guint) == 2) {
3655         arg2 = amglue_SvU16(ST(1));
3656       } else if (sizeof(guint) == 4) {
3657         arg2 = amglue_SvU32(ST(1));
3658       } else if (sizeof(guint) == 8) {
3659         arg2 = amglue_SvU64(ST(1));
3660       } else {
3661         croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
3662       }
3663     }
3664     result = (gboolean)Device_recycle_file(arg1,arg2);
3665     {
3666       if (result)
3667       ST(argvi) = &PL_sv_yes;
3668       else
3669       ST(argvi) = &PL_sv_no;
3670       argvi++;
3671     }
3672
3673     XSRETURN(argvi);
3674   fail:
3675
3676     SWIG_croak_null();
3677   }
3678 }
3679
3680
3681 XS(_wrap_Device_file) {
3682   {
3683     Device *arg1 = (Device *) 0 ;
3684     void *argp1 = 0 ;
3685     int res1 = 0 ;
3686     int argvi = 0;
3687     int result;
3688     dXSARGS;
3689
3690     if ((items < 1) || (items > 1)) {
3691       SWIG_croak("Usage: Device_file(self);");
3692     }
3693     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3694     if (!SWIG_IsOK(res1)) {
3695       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_file" "', argument " "1"" of type '" "Device *""'");
3696     }
3697     arg1 = (Device *)(argp1);
3698     result = (int)Device_file(arg1);
3699     {
3700       SV *for_stack;
3701       SP += argvi; PUTBACK;
3702       for_stack = sv_2mortal(amglue_newSVi64(result));
3703       SPAGAIN; SP -= argvi;
3704       ST(argvi) = for_stack;
3705       argvi++;
3706     }
3707
3708     XSRETURN(argvi);
3709   fail:
3710
3711     SWIG_croak_null();
3712   }
3713 }
3714
3715
3716 XS(_wrap_Device_block) {
3717   {
3718     Device *arg1 = (Device *) 0 ;
3719     void *argp1 = 0 ;
3720     int res1 = 0 ;
3721     int argvi = 0;
3722     guint64 result;
3723     dXSARGS;
3724
3725     if ((items < 1) || (items > 1)) {
3726       SWIG_croak("Usage: Device_block(self);");
3727     }
3728     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3729     if (!SWIG_IsOK(res1)) {
3730       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_block" "', argument " "1"" of type '" "Device *""'");
3731     }
3732     arg1 = (Device *)(argp1);
3733     result = Device_block(arg1);
3734     {
3735       SV *for_stack;
3736       SP += argvi; PUTBACK;
3737       for_stack = sv_2mortal(amglue_newSVu64(result));
3738       SPAGAIN; SP -= argvi;
3739       ST(argvi) = for_stack;
3740       argvi++;
3741     }
3742
3743     XSRETURN(argvi);
3744   fail:
3745
3746     SWIG_croak_null();
3747   }
3748 }
3749
3750
3751 XS(_wrap_Device_in_file) {
3752   {
3753     Device *arg1 = (Device *) 0 ;
3754     void *argp1 = 0 ;
3755     int res1 = 0 ;
3756     int argvi = 0;
3757     gboolean result;
3758     dXSARGS;
3759
3760     if ((items < 1) || (items > 1)) {
3761       SWIG_croak("Usage: Device_in_file(self);");
3762     }
3763     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3764     if (!SWIG_IsOK(res1)) {
3765       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_in_file" "', argument " "1"" of type '" "Device *""'");
3766     }
3767     arg1 = (Device *)(argp1);
3768     result = (gboolean)Device_in_file(arg1);
3769     {
3770       if (result)
3771       ST(argvi) = &PL_sv_yes;
3772       else
3773       ST(argvi) = &PL_sv_no;
3774       argvi++;
3775     }
3776
3777     XSRETURN(argvi);
3778   fail:
3779
3780     SWIG_croak_null();
3781   }
3782 }
3783
3784
3785 XS(_wrap_Device_device_name) {
3786   {
3787     Device *arg1 = (Device *) 0 ;
3788     void *argp1 = 0 ;
3789     int res1 = 0 ;
3790     int argvi = 0;
3791     char *result = 0 ;
3792     dXSARGS;
3793
3794     if ((items < 1) || (items > 1)) {
3795       SWIG_croak("Usage: Device_device_name(self);");
3796     }
3797     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3798     if (!SWIG_IsOK(res1)) {
3799       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_device_name" "', argument " "1"" of type '" "Device *""'");
3800     }
3801     arg1 = (Device *)(argp1);
3802     result = (char *)Device_device_name(arg1);
3803     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3804
3805     XSRETURN(argvi);
3806   fail:
3807
3808     SWIG_croak_null();
3809   }
3810 }
3811
3812
3813 XS(_wrap_Device_access_mode) {
3814   {
3815     Device *arg1 = (Device *) 0 ;
3816     void *argp1 = 0 ;
3817     int res1 = 0 ;
3818     int argvi = 0;
3819     DeviceAccessMode result;
3820     dXSARGS;
3821
3822     if ((items < 1) || (items > 1)) {
3823       SWIG_croak("Usage: Device_access_mode(self);");
3824     }
3825     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3826     if (!SWIG_IsOK(res1)) {
3827       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_access_mode" "', argument " "1"" of type '" "Device *""'");
3828     }
3829     arg1 = (Device *)(argp1);
3830     result = (DeviceAccessMode)Device_access_mode(arg1);
3831     {
3832       SV *for_stack;
3833       SP += argvi; PUTBACK;
3834       for_stack = sv_2mortal(amglue_newSVi64(result));
3835       SPAGAIN; SP -= argvi;
3836       ST(argvi) = for_stack;
3837       argvi++;
3838     }
3839
3840     XSRETURN(argvi);
3841   fail:
3842
3843     SWIG_croak_null();
3844   }
3845 }
3846
3847
3848 XS(_wrap_Device_is_eof) {
3849   {
3850     Device *arg1 = (Device *) 0 ;
3851     void *argp1 = 0 ;
3852     int res1 = 0 ;
3853     int argvi = 0;
3854     gboolean result;
3855     dXSARGS;
3856
3857     if ((items < 1) || (items > 1)) {
3858       SWIG_croak("Usage: Device_is_eof(self);");
3859     }
3860     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3861     if (!SWIG_IsOK(res1)) {
3862       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_is_eof" "', argument " "1"" of type '" "Device *""'");
3863     }
3864     arg1 = (Device *)(argp1);
3865     result = (gboolean)Device_is_eof(arg1);
3866     {
3867       if (result)
3868       ST(argvi) = &PL_sv_yes;
3869       else
3870       ST(argvi) = &PL_sv_no;
3871       argvi++;
3872     }
3873
3874     XSRETURN(argvi);
3875   fail:
3876
3877     SWIG_croak_null();
3878   }
3879 }
3880
3881
3882 XS(_wrap_Device_is_eom) {
3883   {
3884     Device *arg1 = (Device *) 0 ;
3885     void *argp1 = 0 ;
3886     int res1 = 0 ;
3887     int argvi = 0;
3888     gboolean result;
3889     dXSARGS;
3890
3891     if ((items < 1) || (items > 1)) {
3892       SWIG_croak("Usage: Device_is_eom(self);");
3893     }
3894     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3895     if (!SWIG_IsOK(res1)) {
3896       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_is_eom" "', argument " "1"" of type '" "Device *""'");
3897     }
3898     arg1 = (Device *)(argp1);
3899     result = (gboolean)Device_is_eom(arg1);
3900     {
3901       if (result)
3902       ST(argvi) = &PL_sv_yes;
3903       else
3904       ST(argvi) = &PL_sv_no;
3905       argvi++;
3906     }
3907
3908     XSRETURN(argvi);
3909   fail:
3910
3911     SWIG_croak_null();
3912   }
3913 }
3914
3915
3916 XS(_wrap_Device_volume_label) {
3917   {
3918     Device *arg1 = (Device *) 0 ;
3919     void *argp1 = 0 ;
3920     int res1 = 0 ;
3921     int argvi = 0;
3922     char *result = 0 ;
3923     dXSARGS;
3924
3925     if ((items < 1) || (items > 1)) {
3926       SWIG_croak("Usage: Device_volume_label(self);");
3927     }
3928     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3929     if (!SWIG_IsOK(res1)) {
3930       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_label" "', argument " "1"" of type '" "Device *""'");
3931     }
3932     arg1 = (Device *)(argp1);
3933     result = (char *)Device_volume_label(arg1);
3934     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3935
3936     XSRETURN(argvi);
3937   fail:
3938
3939     SWIG_croak_null();
3940   }
3941 }
3942
3943
3944 XS(_wrap_Device_volume_time) {
3945   {
3946     Device *arg1 = (Device *) 0 ;
3947     void *argp1 = 0 ;
3948     int res1 = 0 ;
3949     int argvi = 0;
3950     char *result = 0 ;
3951     dXSARGS;
3952
3953     if ((items < 1) || (items > 1)) {
3954       SWIG_croak("Usage: Device_volume_time(self);");
3955     }
3956     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3957     if (!SWIG_IsOK(res1)) {
3958       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_time" "', argument " "1"" of type '" "Device *""'");
3959     }
3960     arg1 = (Device *)(argp1);
3961     result = (char *)Device_volume_time(arg1);
3962     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3963
3964     XSRETURN(argvi);
3965   fail:
3966
3967     SWIG_croak_null();
3968   }
3969 }
3970
3971
3972 XS(_wrap_Device_status) {
3973   {
3974     Device *arg1 = (Device *) 0 ;
3975     void *argp1 = 0 ;
3976     int res1 = 0 ;
3977     int argvi = 0;
3978     DeviceStatusFlags result;
3979     dXSARGS;
3980
3981     if ((items < 1) || (items > 1)) {
3982       SWIG_croak("Usage: Device_status(self);");
3983     }
3984     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3985     if (!SWIG_IsOK(res1)) {
3986       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_status" "', argument " "1"" of type '" "Device *""'");
3987     }
3988     arg1 = (Device *)(argp1);
3989     result = (DeviceStatusFlags)Device_status(arg1);
3990     {
3991       SV *for_stack;
3992       SP += argvi; PUTBACK;
3993       for_stack = sv_2mortal(amglue_newSVi64(result));
3994       SPAGAIN; SP -= argvi;
3995       ST(argvi) = for_stack;
3996       argvi++;
3997     }
3998
3999     XSRETURN(argvi);
4000   fail:
4001
4002     SWIG_croak_null();
4003   }
4004 }
4005
4006
4007 XS(_wrap_Device_min_block_size) {
4008   {
4009     Device *arg1 = (Device *) 0 ;
4010     void *argp1 = 0 ;
4011     int res1 = 0 ;
4012     int argvi = 0;
4013     gsize result;
4014     dXSARGS;
4015
4016     if ((items < 1) || (items > 1)) {
4017       SWIG_croak("Usage: Device_min_block_size(self);");
4018     }
4019     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
4020     if (!SWIG_IsOK(res1)) {
4021       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_min_block_size" "', argument " "1"" of type '" "Device *""'");
4022     }
4023     arg1 = (Device *)(argp1);
4024     result = Device_min_block_size(arg1);
4025     {
4026       SV *for_stack;
4027       SP += argvi; PUTBACK;
4028       for_stack = sv_2mortal(amglue_newSVu64(result));
4029       SPAGAIN; SP -= argvi;
4030       ST(argvi) = for_stack;
4031       argvi++;
4032     }
4033
4034     XSRETURN(argvi);
4035   fail:
4036
4037     SWIG_croak_null();
4038   }
4039 }
4040
4041
4042 XS(_wrap_Device_max_block_size) {
4043   {
4044     Device *arg1 = (Device *) 0 ;
4045     void *argp1 = 0 ;
4046     int res1 = 0 ;
4047     int argvi = 0;
4048     gsize result;
4049     dXSARGS;
4050
4051     if ((items < 1) || (items > 1)) {
4052       SWIG_croak("Usage: Device_max_block_size(self);");
4053     }
4054     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
4055     if (!SWIG_IsOK(res1)) {
4056       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_max_block_size" "', argument " "1"" of type '" "Device *""'");
4057     }
4058     arg1 = (Device *)(argp1);
4059     result = Device_max_block_size(arg1);
4060     {
4061       SV *for_stack;
4062       SP += argvi; PUTBACK;
4063       for_stack = sv_2mortal(amglue_newSVu64(result));
4064       SPAGAIN; SP -= argvi;
4065       ST(argvi) = for_stack;
4066       argvi++;
4067     }
4068
4069     XSRETURN(argvi);
4070   fail:
4071
4072     SWIG_croak_null();
4073   }
4074 }
4075
4076
4077 XS(_wrap_Device_block_size) {
4078   {
4079     Device *arg1 = (Device *) 0 ;
4080     void *argp1 = 0 ;
4081     int res1 = 0 ;
4082     int argvi = 0;
4083     gsize result;
4084     dXSARGS;
4085
4086     if ((items < 1) || (items > 1)) {
4087       SWIG_croak("Usage: Device_block_size(self);");
4088     }
4089     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
4090     if (!SWIG_IsOK(res1)) {
4091       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_block_size" "', argument " "1"" of type '" "Device *""'");
4092     }
4093     arg1 = (Device *)(argp1);
4094     result = Device_block_size(arg1);
4095     {
4096       SV *for_stack;
4097       SP += argvi; PUTBACK;
4098       for_stack = sv_2mortal(amglue_newSVu64(result));
4099       SPAGAIN; SP -= argvi;
4100       ST(argvi) = for_stack;
4101       argvi++;
4102     }
4103
4104     XSRETURN(argvi);
4105   fail:
4106
4107     SWIG_croak_null();
4108   }
4109 }
4110
4111
4112 XS(_wrap_Device_volume_header) {
4113   {
4114     Device *arg1 = (Device *) 0 ;
4115     void *argp1 = 0 ;
4116     int res1 = 0 ;
4117     int argvi = 0;
4118     dumpfile_t *result = 0 ;
4119     dXSARGS;
4120
4121     if ((items < 1) || (items > 1)) {
4122       SWIG_croak("Usage: Device_volume_header(self);");
4123     }
4124     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
4125     if (!SWIG_IsOK(res1)) {
4126       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_header" "', argument " "1"" of type '" "Device *""'");
4127     }
4128     arg1 = (Device *)(argp1);
4129     result = (dumpfile_t *)Device_volume_header(arg1);
4130     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, 0 | SWIG_SHADOW); argvi++ ;
4131
4132     XSRETURN(argvi);
4133   fail:
4134
4135     SWIG_croak_null();
4136   }
4137 }
4138
4139
4140 XS(_wrap_rait_device_open_from_children) {
4141   {
4142     GSList *arg1 = (GSList *) 0 ;
4143     int argvi = 0;
4144     Device *result = 0 ;
4145     dXSARGS;
4146
4147     if ((items < 1) || (items > 1)) {
4148       SWIG_croak("Usage: rait_device_open_from_children(child_devices);");
4149     }
4150     {
4151       AV *av;
4152       int i, len;
4153
4154       if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
4155         SWIG_exception(SWIG_TypeError, "Expected an arrayref");
4156       }
4157       av = (AV *)SvRV(ST(0));
4158
4159       arg1 = NULL;
4160       len = av_len(av);
4161       for (i = 0; i <= len; i++) {
4162         SV **elt = av_fetch(av, i, 0);
4163         Device *d;
4164
4165         if (elt && !SvOK(*elt)) {
4166           arg1 = g_slist_append(arg1, NULL); /* 'undef' => NULL */
4167         } else if (!elt || SWIG_ConvertPtr(*elt, (void **)&d, SWIGTYPE_p_Device, 0) == -1) {
4168           SWIG_exception(SWIG_TypeError, "array member is not a Device");
4169         } else {
4170           arg1 = g_slist_append(arg1, d);
4171         }
4172       }
4173     }
4174     result = (Device *)rait_device_open_from_children(arg1);
4175     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Device, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
4176     {
4177       g_slist_free(arg1);
4178     }
4179     XSRETURN(argvi);
4180   fail:
4181     {
4182       g_slist_free(arg1);
4183     }
4184     SWIG_croak_null();
4185   }
4186 }
4187
4188
4189 XS(_wrap_write_random_to_device) {
4190   {
4191     guint32 arg1 ;
4192     size_t arg2 ;
4193     Device *arg3 = (Device *) 0 ;
4194     void *argp3 = 0 ;
4195     int res3 = 0 ;
4196     int argvi = 0;
4197     gboolean result;
4198     dXSARGS;
4199
4200     if ((items < 3) || (items > 3)) {
4201       SWIG_croak("Usage: write_random_to_device(seed,length,device);");
4202     }
4203     {
4204       arg1 = amglue_SvU32(ST(0));
4205     }
4206     {
4207       if (sizeof(size_t) == 1) {
4208         arg2 = amglue_SvU8(ST(1));
4209       } else if (sizeof(size_t) == 2) {
4210         arg2 = amglue_SvU16(ST(1));
4211       } else if (sizeof(size_t) == 4) {
4212         arg2 = amglue_SvU32(ST(1));
4213       } else if (sizeof(size_t) == 8) {
4214         arg2 = amglue_SvU64(ST(1));
4215       } else {
4216         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
4217       }
4218     }
4219     res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_Device, 0 |  0 );
4220     if (!SWIG_IsOK(res3)) {
4221       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "write_random_to_device" "', argument " "3"" of type '" "Device *""'");
4222     }
4223     arg3 = (Device *)(argp3);
4224     result = (gboolean)write_random_to_device(arg1,arg2,arg3);
4225     {
4226       if (result)
4227       ST(argvi) = &PL_sv_yes;
4228       else
4229       ST(argvi) = &PL_sv_no;
4230       argvi++;
4231     }
4232
4233
4234     XSRETURN(argvi);
4235   fail:
4236
4237
4238     SWIG_croak_null();
4239   }
4240 }
4241
4242
4243 XS(_wrap_verify_random_from_device) {
4244   {
4245     guint32 arg1 ;
4246     size_t arg2 ;
4247     Device *arg3 = (Device *) 0 ;
4248     void *argp3 = 0 ;
4249     int res3 = 0 ;
4250     int argvi = 0;
4251     gboolean result;
4252     dXSARGS;
4253
4254     if ((items < 3) || (items > 3)) {
4255       SWIG_croak("Usage: verify_random_from_device(seed,length,device);");
4256     }
4257     {
4258       arg1 = amglue_SvU32(ST(0));
4259     }
4260     {
4261       if (sizeof(size_t) == 1) {
4262         arg2 = amglue_SvU8(ST(1));
4263       } else if (sizeof(size_t) == 2) {
4264         arg2 = amglue_SvU16(ST(1));
4265       } else if (sizeof(size_t) == 4) {
4266         arg2 = amglue_SvU32(ST(1));
4267       } else if (sizeof(size_t) == 8) {
4268         arg2 = amglue_SvU64(ST(1));
4269       } else {
4270         croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
4271       }
4272     }
4273     res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_Device, 0 |  0 );
4274     if (!SWIG_IsOK(res3)) {
4275       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "verify_random_from_device" "', argument " "3"" of type '" "Device *""'");
4276     }
4277     arg3 = (Device *)(argp3);
4278     result = (gboolean)verify_random_from_device(arg1,arg2,arg3);
4279     {
4280       if (result)
4281       ST(argvi) = &PL_sv_yes;
4282       else
4283       ST(argvi) = &PL_sv_no;
4284       argvi++;
4285     }
4286
4287
4288     XSRETURN(argvi);
4289   fail:
4290
4291
4292     SWIG_croak_null();
4293   }
4294 }
4295
4296
4297 XS(_wrap_IS_WRITABLE_ACCESS_MODE) {
4298   {
4299     DeviceAccessMode arg1 ;
4300     int argvi = 0;
4301     gboolean result;
4302     dXSARGS;
4303
4304     if ((items < 1) || (items > 1)) {
4305       SWIG_croak("Usage: IS_WRITABLE_ACCESS_MODE(mode);");
4306     }
4307     {
4308       if (sizeof(signed int) == 1) {
4309         arg1 = amglue_SvI8(ST(0));
4310       } else if (sizeof(signed int) == 2) {
4311         arg1 = amglue_SvI16(ST(0));
4312       } else if (sizeof(signed int) == 4) {
4313         arg1 = amglue_SvI32(ST(0));
4314       } else if (sizeof(signed int) == 8) {
4315         arg1 = amglue_SvI64(ST(0));
4316       } else {
4317         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4318       }
4319     }
4320     result = (gboolean)IS_WRITABLE_ACCESS_MODE(arg1);
4321     {
4322       if (result)
4323       ST(argvi) = &PL_sv_yes;
4324       else
4325       ST(argvi) = &PL_sv_no;
4326       argvi++;
4327     }
4328
4329     XSRETURN(argvi);
4330   fail:
4331
4332     SWIG_croak_null();
4333   }
4334 }
4335
4336
4337
4338 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4339
4340 static swig_type_info _swigt__p_Device = {"_p_Device", "struct Device *|Device *", 0, 0, (void*)"Amanda::Device::Device", 0};
4341 static swig_type_info _swigt__p_DevicePropertyBase = {"_p_DevicePropertyBase", "DevicePropertyBase *", 0, 0, (void*)0, 0};
4342 static swig_type_info _swigt__p_DirectTCPAddr = {"_p_DirectTCPAddr", "DirectTCPAddr *", 0, 0, (void*)0, 0};
4343 static swig_type_info _swigt__p_DirectTCPConnection = {"_p_DirectTCPConnection", "struct DirectTCPConnection *|DirectTCPConnection *", 0, 0, (void*)"Amanda::Device::DirectTCPConnection", 0};
4344 static swig_type_info _swigt__p_GSList = {"_p_GSList", "GSList *", 0, 0, (void*)0, 0};
4345 static swig_type_info _swigt__p_GValue = {"_p_GValue", "GValue *", 0, 0, (void*)0, 0};
4346 static swig_type_info _swigt__p_a_STRMAX__char = {"_p_a_STRMAX__char", "char (*)[STRMAX]|string_t *", 0, 0, (void*)0, 0};
4347 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
4348 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
4349 static swig_type_info _swigt__p_dumpfile_t = {"_p_dumpfile_t", "dumpfile_t *", 0, 0, (void*)"Amanda::Header::Header", 0};
4350 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
4351 static swig_type_info _swigt__p_guint = {"_p_guint", "guint *", 0, 0, (void*)0, 0};
4352 static swig_type_info _swigt__p_guint32 = {"_p_guint32", "guint32 *", 0, 0, (void*)0, 0};
4353 static swig_type_info _swigt__p_guint64 = {"_p_guint64", "guint64 *", 0, 0, (void*)0, 0};
4354 static swig_type_info _swigt__p_int = {"_p_int", "int *|PropertySurety *|ConcurrencyParadigm *|filetype_t *|PropertySource *|StreamingRequirement *|gboolean *|DeviceAccessMode *|MediaAccessMode *|DeviceStatusFlags *|PropertyPhaseFlags *|PropertyAccessFlags *", 0, 0, (void*)0, 0};
4355 static swig_type_info _swigt__p_p_DirectTCPAddr = {"_p_p_DirectTCPAddr", "DirectTCPAddr **", 0, 0, (void*)0, 0};
4356 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
4357
4358 static swig_type_info *swig_type_initial[] = {
4359   &_swigt__p_Device,
4360   &_swigt__p_DevicePropertyBase,
4361   &_swigt__p_DirectTCPAddr,
4362   &_swigt__p_DirectTCPConnection,
4363   &_swigt__p_GSList,
4364   &_swigt__p_GValue,
4365   &_swigt__p_a_STRMAX__char,
4366   &_swigt__p_char,
4367   &_swigt__p_double,
4368   &_swigt__p_dumpfile_t,
4369   &_swigt__p_float,
4370   &_swigt__p_guint,
4371   &_swigt__p_guint32,
4372   &_swigt__p_guint64,
4373   &_swigt__p_int,
4374   &_swigt__p_p_DirectTCPAddr,
4375   &_swigt__p_unsigned_char,
4376 };
4377
4378 static swig_cast_info _swigc__p_Device[] = {  {&_swigt__p_Device, 0, 0, 0},{0, 0, 0, 0}};
4379 static swig_cast_info _swigc__p_DevicePropertyBase[] = {  {&_swigt__p_DevicePropertyBase, 0, 0, 0},{0, 0, 0, 0}};
4380 static swig_cast_info _swigc__p_DirectTCPAddr[] = {  {&_swigt__p_DirectTCPAddr, 0, 0, 0},{0, 0, 0, 0}};
4381 static swig_cast_info _swigc__p_DirectTCPConnection[] = {  {&_swigt__p_DirectTCPConnection, 0, 0, 0},{0, 0, 0, 0}};
4382 static swig_cast_info _swigc__p_GSList[] = {  {&_swigt__p_GSList, 0, 0, 0},{0, 0, 0, 0}};
4383 static swig_cast_info _swigc__p_GValue[] = {  {&_swigt__p_GValue, 0, 0, 0},{0, 0, 0, 0}};
4384 static swig_cast_info _swigc__p_a_STRMAX__char[] = {  {&_swigt__p_a_STRMAX__char, 0, 0, 0},{0, 0, 0, 0}};
4385 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
4386 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
4387 static swig_cast_info _swigc__p_dumpfile_t[] = {  {&_swigt__p_dumpfile_t, 0, 0, 0},{0, 0, 0, 0}};
4388 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
4389 static swig_cast_info _swigc__p_guint[] = {  {&_swigt__p_guint, 0, 0, 0},{0, 0, 0, 0}};
4390 static swig_cast_info _swigc__p_guint32[] = {  {&_swigt__p_guint32, 0, 0, 0},{0, 0, 0, 0}};
4391 static swig_cast_info _swigc__p_guint64[] = {  {&_swigt__p_guint64, 0, 0, 0},{0, 0, 0, 0}};
4392 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
4393 static swig_cast_info _swigc__p_p_DirectTCPAddr[] = {  {&_swigt__p_p_DirectTCPAddr, 0, 0, 0},{0, 0, 0, 0}};
4394 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
4395
4396 static swig_cast_info *swig_cast_initial[] = {
4397   _swigc__p_Device,
4398   _swigc__p_DevicePropertyBase,
4399   _swigc__p_DirectTCPAddr,
4400   _swigc__p_DirectTCPConnection,
4401   _swigc__p_GSList,
4402   _swigc__p_GValue,
4403   _swigc__p_a_STRMAX__char,
4404   _swigc__p_char,
4405   _swigc__p_double,
4406   _swigc__p_dumpfile_t,
4407   _swigc__p_float,
4408   _swigc__p_guint,
4409   _swigc__p_guint32,
4410   _swigc__p_guint64,
4411   _swigc__p_int,
4412   _swigc__p_p_DirectTCPAddr,
4413   _swigc__p_unsigned_char,
4414 };
4415
4416
4417 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4418
4419 static swig_constant_info swig_constants[] = {
4420 {0,0,0,0,0,0}
4421 };
4422 #ifdef __cplusplus
4423 }
4424 #endif
4425 static swig_variable_info swig_variables[] = {
4426 {0,0,0,0}
4427 };
4428 static swig_command_info swig_commands[] = {
4429 {"Amanda::Devicec::delete_DirectTCPConnection", _wrap_delete_DirectTCPConnection},
4430 {"Amanda::Devicec::DirectTCPConnection_close", _wrap_DirectTCPConnection_close},
4431 {"Amanda::Devicec::new_DirectTCPConnection", _wrap_new_DirectTCPConnection},
4432 {"Amanda::Devicec::unaliased_name", _wrap_unaliased_name},
4433 {"Amanda::Devicec::new_Device", _wrap_new_Device},
4434 {"Amanda::Devicec::delete_Device", _wrap_delete_Device},
4435 {"Amanda::Devicec::Device_configure", _wrap_Device_configure},
4436 {"Amanda::Devicec::Device_error", _wrap_Device_error},
4437 {"Amanda::Devicec::Device_status_error", _wrap_Device_status_error},
4438 {"Amanda::Devicec::Device_error_or_status", _wrap_Device_error_or_status},
4439 {"Amanda::Devicec::Device_read_label", _wrap_Device_read_label},
4440 {"Amanda::Devicec::Device_start", _wrap_Device_start},
4441 {"Amanda::Devicec::Device_finish", _wrap_Device_finish},
4442 {"Amanda::Devicec::Device_start_file", _wrap_Device_start_file},
4443 {"Amanda::Devicec::Device_write_block", _wrap_Device_write_block},
4444 {"Amanda::Devicec::Device_finish_file", _wrap_Device_finish_file},
4445 {"Amanda::Devicec::Device_seek_file", _wrap_Device_seek_file},
4446 {"Amanda::Devicec::Device_seek_block", _wrap_Device_seek_block},
4447 {"Amanda::Devicec::Device_read_block", _wrap_Device_read_block},
4448 {"Amanda::Devicec::Device_erase", _wrap_Device_erase},
4449 {"Amanda::Devicec::Device_eject", _wrap_Device_eject},
4450 {"Amanda::Devicec::Device_directtcp_supported", _wrap_Device_directtcp_supported},
4451 {"Amanda::Devicec::Device_listen", _wrap_Device_listen},
4452 {"Amanda::Devicec::Device_accept", _wrap_Device_accept},
4453 {"Amanda::Devicec::Device_connect", _wrap_Device_connect},
4454 {"Amanda::Devicec::Device_use_connection", _wrap_Device_use_connection},
4455 {"Amanda::Devicec::Device_write_from_connection", _wrap_Device_write_from_connection},
4456 {"Amanda::Devicec::Device_read_to_connection", _wrap_Device_read_to_connection},
4457 {"Amanda::Devicec::Device_property_list", _wrap_Device_property_list},
4458 {"Amanda::Devicec::Device_property_get", _wrap_Device_property_get},
4459 {"Amanda::Devicec::Device_property_set", _wrap_Device_property_set},
4460 {"Amanda::Devicec::Device_property_set_ex", _wrap_Device_property_set_ex},
4461 {"Amanda::Devicec::Device_recycle_file", _wrap_Device_recycle_file},
4462 {"Amanda::Devicec::Device_file", _wrap_Device_file},
4463 {"Amanda::Devicec::Device_block", _wrap_Device_block},
4464 {"Amanda::Devicec::Device_in_file", _wrap_Device_in_file},
4465 {"Amanda::Devicec::Device_device_name", _wrap_Device_device_name},
4466 {"Amanda::Devicec::Device_access_mode", _wrap_Device_access_mode},
4467 {"Amanda::Devicec::Device_is_eof", _wrap_Device_is_eof},
4468 {"Amanda::Devicec::Device_is_eom", _wrap_Device_is_eom},
4469 {"Amanda::Devicec::Device_volume_label", _wrap_Device_volume_label},
4470 {"Amanda::Devicec::Device_volume_time", _wrap_Device_volume_time},
4471 {"Amanda::Devicec::Device_status", _wrap_Device_status},
4472 {"Amanda::Devicec::Device_min_block_size", _wrap_Device_min_block_size},
4473 {"Amanda::Devicec::Device_max_block_size", _wrap_Device_max_block_size},
4474 {"Amanda::Devicec::Device_block_size", _wrap_Device_block_size},
4475 {"Amanda::Devicec::Device_volume_header", _wrap_Device_volume_header},
4476 {"Amanda::Devicec::rait_device_open_from_children", _wrap_rait_device_open_from_children},
4477 {"Amanda::Devicec::write_random_to_device", _wrap_write_random_to_device},
4478 {"Amanda::Devicec::verify_random_from_device", _wrap_verify_random_from_device},
4479 {"Amanda::Devicec::IS_WRITABLE_ACCESS_MODE", _wrap_IS_WRITABLE_ACCESS_MODE},
4480 {0,0}
4481 };
4482 /* -----------------------------------------------------------------------------
4483  * Type initialization:
4484  * This problem is tough by the requirement that no dynamic
4485  * memory is used. Also, since swig_type_info structures store pointers to
4486  * swig_cast_info structures and swig_cast_info structures store pointers back
4487  * to swig_type_info structures, we need some lookup code at initialization.
4488  * The idea is that swig generates all the structures that are needed.
4489  * The runtime then collects these partially filled structures.
4490  * The SWIG_InitializeModule function takes these initial arrays out of
4491  * swig_module, and does all the lookup, filling in the swig_module.types
4492  * array with the correct data and linking the correct swig_cast_info
4493  * structures together.
4494  *
4495  * The generated swig_type_info structures are assigned staticly to an initial
4496  * array. We just loop through that array, and handle each type individually.
4497  * First we lookup if this type has been already loaded, and if so, use the
4498  * loaded structure instead of the generated one. Then we have to fill in the
4499  * cast linked list. The cast data is initially stored in something like a
4500  * two-dimensional array. Each row corresponds to a type (there are the same
4501  * number of rows as there are in the swig_type_initial array). Each entry in
4502  * a column is one of the swig_cast_info structures for that type.
4503  * The cast_initial array is actually an array of arrays, because each row has
4504  * a variable number of columns. So to actually build the cast linked list,
4505  * we find the array of casts associated with the type, and loop through it
4506  * adding the casts to the list. The one last trick we need to do is making
4507  * sure the type pointer in the swig_cast_info struct is correct.
4508  *
4509  * First off, we lookup the cast->type name to see if it is already loaded.
4510  * There are three cases to handle:
4511  *  1) If the cast->type has already been loaded AND the type we are adding
4512  *     casting info to has not been loaded (it is in this module), THEN we
4513  *     replace the cast->type pointer with the type pointer that has already
4514  *     been loaded.
4515  *  2) If BOTH types (the one we are adding casting info to, and the
4516  *     cast->type) are loaded, THEN the cast info has already been loaded by
4517  *     the previous module so we just ignore it.
4518  *  3) Finally, if cast->type has not already been loaded, then we add that
4519  *     swig_cast_info to the linked list (because the cast->type) pointer will
4520  *     be correct.
4521  * ----------------------------------------------------------------------------- */
4522
4523 #ifdef __cplusplus
4524 extern "C" {
4525 #if 0
4526 } /* c-mode */
4527 #endif
4528 #endif
4529
4530 #if 0
4531 #define SWIGRUNTIME_DEBUG
4532 #endif
4533
4534
4535 SWIGRUNTIME void
4536 SWIG_InitializeModule(void *clientdata) {
4537   size_t i;
4538   swig_module_info *module_head, *iter;
4539   int found, init;
4540
4541   clientdata = clientdata;
4542
4543   /* check to see if the circular list has been setup, if not, set it up */
4544   if (swig_module.next==0) {
4545     /* Initialize the swig_module */
4546     swig_module.type_initial = swig_type_initial;
4547     swig_module.cast_initial = swig_cast_initial;
4548     swig_module.next = &swig_module;
4549     init = 1;
4550   } else {
4551     init = 0;
4552   }
4553
4554   /* Try and load any already created modules */
4555   module_head = SWIG_GetModule(clientdata);
4556   if (!module_head) {
4557     /* This is the first module loaded for this interpreter */
4558     /* so set the swig module into the interpreter */
4559     SWIG_SetModule(clientdata, &swig_module);
4560     module_head = &swig_module;
4561   } else {
4562     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4563     found=0;
4564     iter=module_head;
4565     do {
4566       if (iter==&swig_module) {
4567         found=1;
4568         break;
4569       }
4570       iter=iter->next;
4571     } while (iter!= module_head);
4572
4573     /* if the is found in the list, then all is done and we may leave */
4574     if (found) return;
4575     /* otherwise we must add out module into the list */
4576     swig_module.next = module_head->next;
4577     module_head->next = &swig_module;
4578   }
4579
4580   /* When multiple interpeters are used, a module could have already been initialized in
4581        a different interpreter, but not yet have a pointer in this interpreter.
4582        In this case, we do not want to continue adding types... everything should be
4583        set up already */
4584   if (init == 0) return;
4585
4586   /* Now work on filling in swig_module.types */
4587 #ifdef SWIGRUNTIME_DEBUG
4588   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
4589 #endif
4590   for (i = 0; i < swig_module.size; ++i) {
4591     swig_type_info *type = 0;
4592     swig_type_info *ret;
4593     swig_cast_info *cast;
4594
4595 #ifdef SWIGRUNTIME_DEBUG
4596     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4597 #endif
4598
4599     /* if there is another module already loaded */
4600     if (swig_module.next != &swig_module) {
4601       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4602     }
4603     if (type) {
4604       /* Overwrite clientdata field */
4605 #ifdef SWIGRUNTIME_DEBUG
4606       printf("SWIG_InitializeModule: found type %s\n", type->name);
4607 #endif
4608       if (swig_module.type_initial[i]->clientdata) {
4609         type->clientdata = swig_module.type_initial[i]->clientdata;
4610 #ifdef SWIGRUNTIME_DEBUG
4611         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
4612 #endif
4613       }
4614     } else {
4615       type = swig_module.type_initial[i];
4616     }
4617
4618     /* Insert casting types */
4619     cast = swig_module.cast_initial[i];
4620     while (cast->type) {
4621       /* Don't need to add information already in the list */
4622       ret = 0;
4623 #ifdef SWIGRUNTIME_DEBUG
4624       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4625 #endif
4626       if (swig_module.next != &swig_module) {
4627         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4628 #ifdef SWIGRUNTIME_DEBUG
4629         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4630 #endif
4631       }
4632       if (ret) {
4633         if (type == swig_module.type_initial[i]) {
4634 #ifdef SWIGRUNTIME_DEBUG
4635           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4636 #endif
4637           cast->type = ret;
4638           ret = 0;
4639         } else {
4640           /* Check for casting already in the list */
4641           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4642 #ifdef SWIGRUNTIME_DEBUG
4643           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4644 #endif
4645           if (!ocast) ret = 0;
4646         }
4647       }
4648
4649       if (!ret) {
4650 #ifdef SWIGRUNTIME_DEBUG
4651         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4652 #endif
4653         if (type->cast) {
4654           type->cast->prev = cast;
4655           cast->next = type->cast;
4656         }
4657         type->cast = cast;
4658       }
4659       cast++;
4660     }
4661     /* Set entry in modules->types array equal to the type */
4662     swig_module.types[i] = type;
4663   }
4664   swig_module.types[i] = 0;
4665
4666 #ifdef SWIGRUNTIME_DEBUG
4667   printf("**** SWIG_InitializeModule: Cast List ******\n");
4668   for (i = 0; i < swig_module.size; ++i) {
4669     int j = 0;
4670     swig_cast_info *cast = swig_module.cast_initial[i];
4671     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4672     while (cast->type) {
4673       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4674       cast++;
4675       ++j;
4676     }
4677     printf("---- Total casts: %d\n",j);
4678   }
4679   printf("**** SWIG_InitializeModule: Cast List ******\n");
4680 #endif
4681 }
4682
4683 /* This function will propagate the clientdata field of type to
4684 * any new swig_type_info structures that have been added into the list
4685 * of equivalent types.  It is like calling
4686 * SWIG_TypeClientData(type, clientdata) a second time.
4687 */
4688 SWIGRUNTIME void
4689 SWIG_PropagateClientData(void) {
4690   size_t i;
4691   swig_cast_info *equiv;
4692   static int init_run = 0;
4693
4694   if (init_run) return;
4695   init_run = 1;
4696
4697   for (i = 0; i < swig_module.size; i++) {
4698     if (swig_module.types[i]->clientdata) {
4699       equiv = swig_module.types[i]->cast;
4700       while (equiv) {
4701         if (!equiv->converter) {
4702           if (equiv->type && !equiv->type->clientdata)
4703           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4704         }
4705         equiv = equiv->next;
4706       }
4707     }
4708   }
4709 }
4710
4711 #ifdef __cplusplus
4712 #if 0
4713 {
4714   /* c-mode */
4715 #endif
4716 }
4717 #endif
4718
4719
4720
4721 #ifdef __cplusplus
4722 extern "C"
4723 #endif
4724
4725 XS(SWIG_init) {
4726   dXSARGS;
4727   int i;
4728
4729   SWIG_InitializeModule(0);
4730
4731   /* Install commands */
4732   for (i = 0; swig_commands[i].name; i++) {
4733     newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
4734   }
4735
4736   /* Install variables */
4737   for (i = 0; swig_variables[i].name; i++) {
4738     SV *sv;
4739     sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
4740     if (swig_variables[i].type) {
4741       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
4742     } else {
4743       sv_setiv(sv,(IV) 0);
4744     }
4745     swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
4746   }
4747
4748   /* Install constant */
4749   for (i = 0; swig_constants[i].type; i++) {
4750     SV *sv;
4751     sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
4752     switch(swig_constants[i].type) {
4753     case SWIG_INT:
4754       sv_setiv(sv, (IV) swig_constants[i].lvalue);
4755       break;
4756     case SWIG_FLOAT:
4757       sv_setnv(sv, (double) swig_constants[i].dvalue);
4758       break;
4759     case SWIG_STRING:
4760       sv_setpv(sv, (char *) swig_constants[i].pvalue);
4761       break;
4762     case SWIG_POINTER:
4763       SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
4764       break;
4765     case SWIG_BINARY:
4766       SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
4767       break;
4768     default:
4769       break;
4770     }
4771     SvREADONLY_on(sv);
4772   }
4773
4774
4775   /* Initialize the Device API on load */
4776   device_api_init();
4777
4778   SWIG_TypeClientData(SWIGTYPE_p_DirectTCPConnection, (void*) "Amanda::Device::DirectTCPConnection");
4779   SWIG_TypeClientData(SWIGTYPE_p_Device, (void*) "Amanda::Device::Device");
4780   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4781     SV *sv = get_sv((char*) SWIG_prefix "ACCESS_NULL", TRUE | 0x2 | GV_ADDMULTI);
4782     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_NULL)));
4783     SvREADONLY_on(sv);
4784   } while(0) /*@SWIG@*/;
4785   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4786     SV *sv = get_sv((char*) SWIG_prefix "ACCESS_READ", TRUE | 0x2 | GV_ADDMULTI);
4787     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_READ)));
4788     SvREADONLY_on(sv);
4789   } while(0) /*@SWIG@*/;
4790   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4791     SV *sv = get_sv((char*) SWIG_prefix "ACCESS_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4792     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_WRITE)));
4793     SvREADONLY_on(sv);
4794   } while(0) /*@SWIG@*/;
4795   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4796     SV *sv = get_sv((char*) SWIG_prefix "ACCESS_APPEND", TRUE | 0x2 | GV_ADDMULTI);
4797     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_APPEND)));
4798     SvREADONLY_on(sv);
4799   } while(0) /*@SWIG@*/;
4800   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4801     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
4802     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_SUCCESS)));
4803     SvREADONLY_on(sv);
4804   } while(0) /*@SWIG@*/;
4805   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4806     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_DEVICE_ERROR", TRUE | 0x2 | GV_ADDMULTI);
4807     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_DEVICE_ERROR)));
4808     SvREADONLY_on(sv);
4809   } while(0) /*@SWIG@*/;
4810   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4811     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_DEVICE_BUSY", TRUE | 0x2 | GV_ADDMULTI);
4812     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_DEVICE_BUSY)));
4813     SvREADONLY_on(sv);
4814   } while(0) /*@SWIG@*/;
4815   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4816     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_MISSING", TRUE | 0x2 | GV_ADDMULTI);
4817     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_MISSING)));
4818     SvREADONLY_on(sv);
4819   } while(0) /*@SWIG@*/;
4820   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4821     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_UNLABELED", TRUE | 0x2 | GV_ADDMULTI);
4822     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_UNLABELED)));
4823     SvREADONLY_on(sv);
4824   } while(0) /*@SWIG@*/;
4825   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4826     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_ERROR", TRUE | 0x2 | GV_ADDMULTI);
4827     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_ERROR)));
4828     SvREADONLY_on(sv);
4829   } while(0) /*@SWIG@*/;
4830   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4831     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_FLAGS_MAX", TRUE | 0x2 | GV_ADDMULTI);
4832     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_FLAGS_MAX)));
4833     SvREADONLY_on(sv);
4834   } while(0) /*@SWIG@*/;
4835   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4836     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
4837     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BEFORE_START)));
4838     SvREADONLY_on(sv);
4839   } while(0) /*@SWIG@*/;
4840   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4841     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4842     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BETWEEN_FILE_WRITE)));
4843     SvREADONLY_on(sv);
4844   } while(0) /*@SWIG@*/;
4845   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4846     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4847     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_INSIDE_FILE_WRITE)));
4848     SvREADONLY_on(sv);
4849   } while(0) /*@SWIG@*/;
4850   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4851     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4852     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BETWEEN_FILE_READ)));
4853     SvREADONLY_on(sv);
4854   } while(0) /*@SWIG@*/;
4855   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4856     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4857     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_INSIDE_FILE_READ)));
4858     SvREADONLY_on(sv);
4859   } while(0) /*@SWIG@*/;
4860   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4861     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_MAX", TRUE | 0x2 | GV_ADDMULTI);
4862     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_MAX)));
4863     SvREADONLY_on(sv);
4864   } while(0) /*@SWIG@*/;
4865   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4866     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_MASK", TRUE | 0x2 | GV_ADDMULTI);
4867     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_MASK)));
4868     SvREADONLY_on(sv);
4869   } while(0) /*@SWIG@*/;
4870   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4871     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_SHIFT", TRUE | 0x2 | GV_ADDMULTI);
4872     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_SHIFT)));
4873     SvREADONLY_on(sv);
4874   } while(0) /*@SWIG@*/;
4875   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4876     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
4877     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BEFORE_START)));
4878     SvREADONLY_on(sv);
4879   } while(0) /*@SWIG@*/;
4880   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4881     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4882     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE)));
4883     SvREADONLY_on(sv);
4884   } while(0) /*@SWIG@*/;
4885   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4886     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4887     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE)));
4888     SvREADONLY_on(sv);
4889   } while(0) /*@SWIG@*/;
4890   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4891     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4892     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BETWEEN_FILE_READ)));
4893     SvREADONLY_on(sv);
4894   } while(0) /*@SWIG@*/;
4895   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4896     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4897     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_INSIDE_FILE_READ)));
4898     SvREADONLY_on(sv);
4899   } while(0) /*@SWIG@*/;
4900   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4901     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
4902     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BEFORE_START)));
4903     SvREADONLY_on(sv);
4904   } while(0) /*@SWIG@*/;
4905   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4906     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4907     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE)));
4908     SvREADONLY_on(sv);
4909   } while(0) /*@SWIG@*/;
4910   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4911     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4912     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE)));
4913     SvREADONLY_on(sv);
4914   } while(0) /*@SWIG@*/;
4915   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4916     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4917     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BETWEEN_FILE_READ)));
4918     SvREADONLY_on(sv);
4919   } while(0) /*@SWIG@*/;
4920   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4921     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4922     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_INSIDE_FILE_READ)));
4923     SvREADONLY_on(sv);
4924   } while(0) /*@SWIG@*/;
4925   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4926     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_MASK", TRUE | 0x2 | GV_ADDMULTI);
4927     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_MASK)));
4928     SvREADONLY_on(sv);
4929   } while(0) /*@SWIG@*/;
4930   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4931     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_MASK", TRUE | 0x2 | GV_ADDMULTI);
4932     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_MASK)));
4933     SvREADONLY_on(sv);
4934   } while(0) /*@SWIG@*/;
4935   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4936     SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_EXCLUSIVE", TRUE | 0x2 | GV_ADDMULTI);
4937     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_EXCLUSIVE)));
4938     SvREADONLY_on(sv);
4939   } while(0) /*@SWIG@*/;
4940   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4941     SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_SHARED_READ", TRUE | 0x2 | GV_ADDMULTI);
4942     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_SHARED_READ)));
4943     SvREADONLY_on(sv);
4944   } while(0) /*@SWIG@*/;
4945   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4946     SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_RANDOM_ACCESS", TRUE | 0x2 | GV_ADDMULTI);
4947     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_RANDOM_ACCESS)));
4948     SvREADONLY_on(sv);
4949   } while(0) /*@SWIG@*/;
4950   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4951     SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_NONE", TRUE | 0x2 | GV_ADDMULTI);
4952     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_NONE)));
4953     SvREADONLY_on(sv);
4954   } while(0) /*@SWIG@*/;
4955   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4956     SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_DESIRED", TRUE | 0x2 | GV_ADDMULTI);
4957     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_DESIRED)));
4958     SvREADONLY_on(sv);
4959   } while(0) /*@SWIG@*/;
4960   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4961     SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_REQUIRED", TRUE | 0x2 | GV_ADDMULTI);
4962     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_REQUIRED)));
4963     SvREADONLY_on(sv);
4964   } while(0) /*@SWIG@*/;
4965   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4966     SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_READ_ONLY", TRUE | 0x2 | GV_ADDMULTI);
4967     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_READ_ONLY)));
4968     SvREADONLY_on(sv);
4969   } while(0) /*@SWIG@*/;
4970   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4971     SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_WORM", TRUE | 0x2 | GV_ADDMULTI);
4972     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_WORM)));
4973     SvREADONLY_on(sv);
4974   } while(0) /*@SWIG@*/;
4975   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4976     SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_READ_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4977     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_READ_WRITE)));
4978     SvREADONLY_on(sv);
4979   } while(0) /*@SWIG@*/;
4980   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4981     SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_WRITE_ONLY", TRUE | 0x2 | GV_ADDMULTI);
4982     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_WRITE_ONLY)));
4983     SvREADONLY_on(sv);
4984   } while(0) /*@SWIG@*/;
4985   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4986     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SURETY_BAD", TRUE | 0x2 | GV_ADDMULTI);
4987     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SURETY_BAD)));
4988     SvREADONLY_on(sv);
4989   } while(0) /*@SWIG@*/;
4990   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4991     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SURETY_GOOD", TRUE | 0x2 | GV_ADDMULTI);
4992     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SURETY_GOOD)));
4993     SvREADONLY_on(sv);
4994   } while(0) /*@SWIG@*/;
4995   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4996     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_DEFAULT", TRUE | 0x2 | GV_ADDMULTI);
4997     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_DEFAULT)));
4998     SvREADONLY_on(sv);
4999   } while(0) /*@SWIG@*/;
5000   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5001     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_DETECTED", TRUE | 0x2 | GV_ADDMULTI);
5002     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_DETECTED)));
5003     SvREADONLY_on(sv);
5004   } while(0) /*@SWIG@*/;
5005   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5006     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_USER", TRUE | 0x2 | GV_ADDMULTI);
5007     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_USER)));
5008     SvREADONLY_on(sv);
5009   } while(0) /*@SWIG@*/;
5010   ST(0) = &PL_sv_yes;
5011   XSRETURN(1);
5012 }
5013