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