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_DirectTCPConnection swig_types[2]
1480 #define SWIGTYPE_p_GSList swig_types[3]
1481 #define SWIGTYPE_p_GValue swig_types[4]
1482 #define SWIGTYPE_p_a_STRMAX__char swig_types[5]
1483 #define SWIGTYPE_p_char swig_types[6]
1484 #define SWIGTYPE_p_double swig_types[7]
1485 #define SWIGTYPE_p_dumpfile_t swig_types[8]
1486 #define SWIGTYPE_p_float swig_types[9]
1487 #define SWIGTYPE_p_guint swig_types[10]
1488 #define SWIGTYPE_p_guint64 swig_types[11]
1489 #define SWIGTYPE_p_int swig_types[12]
1490 #define SWIGTYPE_p_p_DirectTCPAddr swig_types[13]
1491 #define SWIGTYPE_p_queue_fd_t swig_types[14]
1492 #define SWIGTYPE_p_unsigned_char swig_types[15]
1493 static swig_type_info *swig_types[17];
1494 static swig_module_info swig_module = {swig_types, 16, 0, 0, 0, 0};
1495 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1496 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1497
1498 /* -------- TYPES TABLE (END) -------- */
1499
1500 #define SWIG_init    boot_Amanda__Device
1501
1502 #define SWIG_name   "Amanda::Devicec::boot_Amanda__Device"
1503 #define SWIG_prefix "Amanda::Devicec::"
1504
1505 #define SWIGVERSION 0x010339
1506 #define SWIG_VERSION SWIGVERSION
1507
1508
1509 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1510 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1511
1512
1513 #ifdef __cplusplus
1514 extern "C"
1515 #endif
1516 #ifndef PERL_OBJECT
1517 #ifndef MULTIPLICITY
1518 SWIGEXPORT void SWIG_init (CV* cv);
1519 #else
1520 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1521 #endif
1522 #else
1523 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1524 #endif
1525
1526
1527 #include "amglue.h"
1528
1529
1530 #include "amglue.h"
1531
1532
1533 #include "amglue.h"
1534
1535
1536 #include "device.h"
1537 #include "property.h"
1538 #include "fileheader.h"
1539 #include "glib-util.h"
1540
1541
1542
1543 /* Utility functions for typemaps, below */
1544
1545 /* return a new, mortal SV corresponding to the given GValue
1546  *
1547  * @param value: the value to convert
1548  * @returns: a new, mortal SV
1549  */
1550 static SV *
1551 set_sv_from_gvalue(GValue *value)
1552 {
1553     GType fundamental = G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value));
1554     SV *sv = NULL;
1555
1556     /* complex reference types */
1557     switch (fundamental) {
1558         case G_TYPE_LONG:
1559             return sv_2mortal(amglue_newSVi64(g_value_get_long(value)));
1560
1561         case G_TYPE_ULONG:
1562             return sv_2mortal(amglue_newSVu64(g_value_get_ulong(value)));
1563
1564         case G_TYPE_INT64:
1565             return sv_2mortal(amglue_newSVi64(g_value_get_int64(value)));
1566
1567         case G_TYPE_UINT64:
1568             return sv_2mortal(amglue_newSVu64(g_value_get_uint64(value)));
1569
1570         case G_TYPE_BOXED: {
1571             GType boxed_type = G_VALUE_TYPE(value);
1572             QualifiedSize qs;
1573             HV *hv;
1574
1575             if (boxed_type == QUALIFIED_SIZE_TYPE) {
1576                 qs = *(QualifiedSize*)(g_value_get_boxed(value));
1577
1578                 /* build a hash */
1579                 hv = (HV *)sv_2mortal((SV *)newHV());
1580                 hv_store(hv, "accuracy", 8, newSViv(qs.accuracy), 0);
1581                 hv_store(hv, "bytes", 5, amglue_newSVi64(qs.bytes), 0);
1582
1583                 sv = newRV((SV *)hv);
1584                 return newRV((SV *)hv);
1585             } else {
1586                 warn("Unsupported boxed property type #%d", (int)boxed_type);
1587
1588                 sv = sv_newmortal();
1589                 sv_setsv(sv, &PL_sv_undef);
1590                 return sv;
1591             }
1592         }
1593     }
1594
1595     /* simple types that can be constructed with sv_set*v */
1596     sv = sv_newmortal();
1597     switch (fundamental) {
1598         case G_TYPE_CHAR:
1599             sv_setiv(sv, g_value_get_char(value));
1600             break;
1601
1602         case G_TYPE_UCHAR:
1603             sv_setuv(sv, g_value_get_uchar(value));
1604             break;
1605
1606         case G_TYPE_BOOLEAN:
1607             sv_setiv(sv, g_value_get_boolean(value));
1608             break;
1609
1610         case G_TYPE_INT:
1611             sv_setiv(sv, g_value_get_int(value));
1612             break;
1613
1614         case G_TYPE_UINT:
1615             sv_setuv(sv, g_value_get_uint(value));
1616             break;
1617
1618         case G_TYPE_FLOAT:
1619             sv_setnv(sv, g_value_get_float(value));
1620             break;
1621
1622         case G_TYPE_DOUBLE:
1623             sv_setnv(sv, g_value_get_double(value));
1624             break;
1625
1626         case G_TYPE_STRING:
1627             sv_setpv(sv, g_value_get_string(value));
1628             break;
1629
1630         case G_TYPE_ENUM:
1631             sv_setiv(sv, g_value_get_enum(value));
1632             break;
1633
1634         case G_TYPE_FLAGS:
1635             sv_setiv(sv, g_value_get_flags(value));
1636             break;
1637
1638         /* Unsupported */
1639         default:
1640         case G_TYPE_POINTER:
1641         case G_TYPE_INTERFACE:
1642         case G_TYPE_OBJECT:
1643         case G_TYPE_PARAM:
1644             warn("Unsupported fundamental property type #%d", (int)fundamental);
1645             sv_setsv(sv, &PL_sv_undef);
1646             break;
1647     }
1648
1649     return sv;
1650 }
1651
1652 /* Given an SV and an initialized GValue, set the GValue to the value
1653  * represented by the SV.  The GValue's type must already be set.
1654  *
1655  * For basic corresponding types (string -> string, integer -> integer),
1656  * the translation is straightforward.  However, if the GValue is not a
1657  * string, but the SV has a string value, then g_value_set_from_string will
1658  * be used to parse the string.
1659  *
1660  * @param sv: SV to convert
1661  * @param value: (input/output) destination
1662  * @returns: TRUE on success
1663  */
1664 static gboolean
1665 set_gvalue_from_sv(SV *sv, GValue *value)
1666 {
1667     GType fundamental = G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value));
1668
1669     /* if we got a string, use g_value_set_from_string to parse any funny
1670      * values or suffixes */
1671     if (SvPOK(sv)) {
1672         if (g_value_set_from_string(value, SvPV_nolen(sv)))
1673             return TRUE;
1674     }
1675
1676     /* otherwise, handle numeric types with SvIV, SvNV, or the amglue_* functions */
1677     switch (fundamental) {
1678         case G_TYPE_BOOLEAN:
1679             g_value_set_boolean(value, SvIV(sv));
1680             return TRUE;
1681
1682         case G_TYPE_CHAR:
1683             g_value_set_char(value, amglue_SvI8(sv));
1684             return TRUE;
1685
1686         case G_TYPE_UCHAR:
1687             g_value_set_uchar(value, amglue_SvU8(sv));
1688             return TRUE;
1689
1690         case G_TYPE_INT:
1691             g_value_set_int(value, amglue_SvI32(sv));
1692             return TRUE;
1693
1694         case G_TYPE_UINT:
1695             g_value_set_uint(value, amglue_SvU32(sv));
1696             return TRUE;
1697
1698         case G_TYPE_LONG:
1699             g_value_set_int64(value, amglue_SvI64(sv));
1700             return TRUE;
1701
1702         case G_TYPE_ULONG:
1703             g_value_set_uint64(value, amglue_SvU64(sv));
1704             return TRUE;
1705
1706         case G_TYPE_INT64:
1707             g_value_set_int64(value, amglue_SvI64(sv));
1708             return TRUE;
1709
1710         case G_TYPE_UINT64:
1711             g_value_set_uint64(value, amglue_SvU64(sv));
1712             return TRUE;
1713
1714         case G_TYPE_FLOAT:
1715             g_value_set_float(value, SvNV(sv));
1716             return TRUE;
1717
1718         case G_TYPE_DOUBLE:
1719             g_value_set_double(value, SvNV(sv));
1720             return TRUE;
1721
1722         case G_TYPE_ENUM:
1723             g_value_set_enum(value, SvIV(sv));
1724             return TRUE;
1725
1726         case G_TYPE_FLAGS:
1727             g_value_set_flags(value, SvIV(sv));
1728             return TRUE;
1729
1730         default:
1731             /* for anything else, let perl stringify it for us and try parsing it */
1732             return g_value_set_from_string(value, SvPV_nolen(sv));
1733     }
1734 }
1735
1736
1737 SWIGINTERN void delete_DirectTCPConnection(DirectTCPConnection *self){
1738             g_object_unref(self);
1739         }
1740 SWIGINTERN char *DirectTCPConnection_close(DirectTCPConnection *self){
1741             return directtcp_connection_close(self);
1742         }
1743
1744 SWIGINTERNINLINE SV *
1745 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1746 {
1747   SV *obj = sv_newmortal();
1748   if (carray) {
1749     sv_setpvn(obj, carray, size);
1750   } else {
1751     sv_setsv(obj, &PL_sv_undef);
1752   }
1753   return obj;
1754 }
1755
1756
1757 SWIGINTERNINLINE SV *
1758 SWIG_FromCharPtr(const char *cptr)
1759 {
1760   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1761 }
1762
1763
1764 #include <limits.h>
1765 #if !defined(SWIG_NO_LLONG_MAX)
1766 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1767 #   define LLONG_MAX __LONG_LONG_MAX__
1768 #   define LLONG_MIN (-LLONG_MAX - 1LL)
1769 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1770 # endif
1771 #endif
1772
1773
1774 SWIGINTERN int
1775 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1776 {
1777   if (SvNIOK(obj)) {
1778     if (val) *val = SvNV(obj);
1779     return SWIG_OK;
1780   } else if (SvIOK(obj)) {
1781     if (val) *val = (double) SvIV(obj);
1782     return SWIG_AddCast(SWIG_OK);
1783   } else {
1784     const char *nptr = SvPV_nolen(obj);
1785     if (nptr) {
1786       char *endptr;
1787       double v = strtod(nptr, &endptr);
1788       if (errno == ERANGE) {
1789         errno = 0;
1790         return SWIG_OverflowError;
1791       } else {
1792         if (*endptr == '\0') {
1793           if (val) *val = v;
1794           return SWIG_Str2NumCast(SWIG_OK);
1795         }
1796       }
1797     }
1798   }
1799   return SWIG_TypeError;
1800 }
1801
1802
1803 #include <float.h>
1804
1805
1806 #include <math.h>
1807
1808
1809 SWIGINTERNINLINE int
1810 SWIG_CanCastAsInteger(double *d, double min, double max) {
1811   double x = *d;
1812   if ((min <= x && x <= max)) {
1813    double fx = floor(x);
1814    double cx = ceil(x);
1815    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1816    if ((errno == EDOM) || (errno == ERANGE)) {
1817      errno = 0;
1818    } else {
1819      double summ, reps, diff;
1820      if (rd < x) {
1821        diff = x - rd;
1822      } else if (rd > x) {
1823        diff = rd - x;
1824      } else {
1825        return 1;
1826      }
1827      summ = rd + x;
1828      reps = diff/summ;
1829      if (reps < 8*DBL_EPSILON) {
1830        *d = rd;
1831        return 1;
1832      }
1833    }
1834   }
1835   return 0;
1836 }
1837
1838
1839 SWIGINTERN int
1840 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1841 {
1842   if (SvIOK(obj)) {
1843     if (val) *val = SvIV(obj);
1844     return SWIG_OK;
1845   } else {
1846     int dispatch = 0;
1847     const char *nptr = SvPV_nolen(obj);
1848     if (nptr) {
1849       char *endptr;
1850       long v;
1851       errno = 0;
1852       v = strtol(nptr, &endptr,0);
1853       if (errno == ERANGE) {
1854         errno = 0;
1855         return SWIG_OverflowError;
1856       } else {
1857         if (*endptr == '\0') {
1858           if (val) *val = v;
1859           return SWIG_Str2NumCast(SWIG_OK);
1860         }
1861       }
1862     }
1863     if (!dispatch) {
1864       double d;
1865       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1866       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1867         if (val) *val = (long)(d);
1868         return res;
1869       }
1870     }
1871   }
1872   return SWIG_TypeError;
1873 }
1874
1875
1876 SWIGINTERN int
1877 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1878 {
1879   long v;
1880   int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1881   if (SWIG_IsOK(res)) {
1882     if ((v < INT_MIN || v > INT_MAX)) {
1883       return SWIG_OverflowError;
1884     } else {
1885       if (val) *val = (int)(v);
1886     }
1887   }
1888   return res;
1889 }
1890
1891 SWIGINTERN queue_fd_t *new_queue_fd_t(int fd){
1892             return queue_fd_new(fd, NULL);
1893         }
1894 SWIGINTERN void delete_queue_fd_t(queue_fd_t *self){
1895             amfree(self->errmsg);
1896             g_free(self);
1897         }
1898
1899 SWIGINTERN swig_type_info*
1900 SWIG_pchar_descriptor(void)
1901 {
1902   static int init = 0;
1903   static swig_type_info* info = 0;
1904   if (!init) {
1905     info = SWIG_TypeQuery("_p_char");
1906     init = 1;
1907   }
1908   return info;
1909 }
1910
1911
1912 SWIGINTERN int
1913 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1914 {
1915   if (SvMAGICAL(obj)) {
1916      SV *tmp = sv_newmortal();
1917      SvSetSV(tmp, obj);
1918      obj = tmp;
1919   }
1920   if (SvPOK(obj)) {
1921     STRLEN len = 0;
1922     char *cstr = SvPV(obj, len);
1923     size_t size = len + 1;
1924     if (cptr)  {
1925       if (alloc) {
1926         if (*alloc == SWIG_NEWOBJ) {
1927           *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1928         } else {
1929           *cptr = cstr;
1930           *alloc = SWIG_OLDOBJ;
1931         }
1932       }
1933     }
1934     if (psize) *psize = size;
1935     return SWIG_OK;
1936   } else {
1937     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1938     if (pchar_descriptor) {
1939       char* vptr = 0;
1940       if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1941         if (cptr) *cptr = vptr;
1942         if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1943         if (alloc) *alloc = SWIG_OLDOBJ;
1944         return SWIG_OK;
1945       }
1946     }
1947   }
1948   return SWIG_TypeError;
1949 }
1950
1951
1952
1953
1954 SWIGINTERN Device *new_Device(char *device_name){
1955             return device_open(device_name);
1956         }
1957 SWIGINTERN void delete_Device(Device *self){
1958             g_object_unref(self);
1959         }
1960 SWIGINTERN gboolean Device_configure(Device *self,gboolean use_global_config){
1961             return device_configure(self, use_global_config);
1962         }
1963 SWIGINTERN char *Device_error(Device *self){
1964             return device_error(self);
1965         }
1966 SWIGINTERN char *Device_status_error(Device *self){
1967             return device_status_error(self);
1968         }
1969 SWIGINTERN char *Device_error_or_status(Device *self){
1970             return device_error_or_status(self);
1971         }
1972 SWIGINTERN DeviceStatusFlags Device_read_label(Device *self){
1973             return device_read_label(self);
1974         }
1975 SWIGINTERN gboolean Device_start(Device *self,DeviceAccessMode mode,char *label,char *timestamp){
1976             return device_start(self, mode, label, timestamp);
1977         }
1978 SWIGINTERN gboolean Device_finish(Device *self){
1979             return device_finish(self);
1980         }
1981 SWIGINTERN gboolean Device_start_file(Device *self,dumpfile_t *jobInfo){
1982             return device_start_file(self, jobInfo);
1983         }
1984 SWIGINTERN gboolean Device_write_block(Device *self,guint size,gpointer data){
1985             return device_write_block(self, size, data);
1986         }
1987 SWIGINTERN gboolean Device_write_from_fd(Device *self,queue_fd_t *queue_fd){
1988             return device_write_from_fd(self, queue_fd);
1989         }
1990 SWIGINTERN gboolean Device_finish_file(Device *self){
1991             return device_finish_file(self);
1992         }
1993 SWIGINTERN dumpfile_t *Device_seek_file(Device *self,guint file){
1994             return device_seek_file(self, file);
1995         }
1996 SWIGINTERN gboolean Device_seek_block(Device *self,guint64 block){
1997             return device_seek_block(self, block);
1998         }
1999 SWIGINTERN int Device_read_block(Device *self,gpointer buffer,int *size){
2000             return device_read_block(self, buffer, size);
2001         }
2002 SWIGINTERN gboolean Device_read_to_fd(Device *self,queue_fd_t *queue_fd){
2003             return device_read_to_fd(self, queue_fd);
2004         }
2005 SWIGINTERN gboolean Device_erase(Device *self){
2006             return device_erase(self);
2007         }
2008 SWIGINTERN gboolean Device_eject(Device *self){
2009             return device_eject(self);
2010         }
2011 SWIGINTERN gboolean Device_directtcp_supported(Device *self){
2012             return device_directtcp_supported(self);
2013         }
2014 SWIGINTERN void Device_listen(Device *self,gboolean for_writing,DirectTCPAddr **addrs){
2015             /* ensure that the addresses are empty if there was an error */
2016             if (!device_listen(self, for_writing, addrs))
2017                 *addrs = NULL;
2018         }
2019 SWIGINTERN DirectTCPConnection *Device_accept(Device *self){
2020             DirectTCPConnection *conn = NULL;
2021             gboolean rv;
2022
2023             rv = device_accept(self, &conn, NULL, NULL);
2024             if (!rv && conn) {
2025                 /* conn is ref'd for our convenience, but we don't want it */
2026                 g_object_unref(conn);
2027                 conn = NULL;
2028             }
2029             return conn;
2030         }
2031 SWIGINTERN gboolean Device_use_connection(Device *self,DirectTCPConnection *conn){
2032             return device_use_connection(self, conn);
2033         }
2034 SWIGINTERN gboolean Device_write_from_connection(Device *self,guint64 size,guint64 *actual_size){
2035             return device_write_from_connection(self, size, actual_size);
2036         }
2037 SWIGINTERN gboolean Device_read_to_connection(Device *self,guint64 size,guint64 *actual_size){
2038             return device_read_to_connection(self, size, actual_size);
2039         }
2040 SWIGINTERN GSList const *Device_property_list(Device *self){
2041             return device_property_get_list(self);
2042         }
2043 SWIGINTERN void Device_property_get(Device *self,DevicePropertyBase *pbase,GValue *out_val,PropertySurety *surety,PropertySource *source,gboolean *val_found){
2044             *val_found = device_property_get_ex(self, pbase->ID, out_val, surety, source);
2045         }
2046 SWIGINTERN gboolean Device_property_set(Device *self,DevicePropertyBase *pbase,SV *sv){
2047             GValue gval;
2048             memset(&gval, 0, sizeof(gval));
2049             g_value_init(&gval, pbase->type);
2050             if (!set_gvalue_from_sv(sv, &gval))
2051                 goto fail;
2052
2053             if (!device_property_set(self, pbase->ID, &gval))
2054                 goto fail;
2055
2056             g_value_unset(&gval);
2057             return TRUE;
2058         fail:
2059             g_value_unset(&gval);
2060             return FALSE;
2061         }
2062 SWIGINTERN gboolean Device_property_set_ex(Device *self,DevicePropertyBase *pbase,SV *sv,PropertySurety surety,PropertySource source){
2063             GValue gval;
2064             memset(&gval, 0, sizeof(gval));
2065             g_value_init(&gval, pbase->type);
2066             if (!set_gvalue_from_sv(sv, &gval))
2067                 goto fail;
2068
2069             if (!device_property_set_ex(self, pbase->ID, &gval, surety, source))
2070                 goto fail;
2071
2072             g_value_unset(&gval);
2073             return TRUE;
2074         fail:
2075             g_value_unset(&gval);
2076             return FALSE;
2077         }
2078 SWIGINTERN gboolean Device_recycle_file(Device *self,guint filenum){
2079             return device_recycle_file(self, filenum);
2080         }
2081 SWIGINTERN int Device_file(Device *self){ return self->file; }
2082 SWIGINTERN guint64 Device_block(Device *self){ return self->block; }
2083 SWIGINTERN gboolean Device_in_file(Device *self){ return self->in_file; }
2084 SWIGINTERN char *Device_device_name(Device *self){ return self->device_name; }
2085 SWIGINTERN DeviceAccessMode Device_access_mode(Device *self){ return self->access_mode; }
2086 SWIGINTERN gboolean Device_is_eof(Device *self){ return self->is_eof; }
2087 SWIGINTERN gboolean Device_is_eom(Device *self){ return self->is_eom; }
2088 SWIGINTERN char *Device_volume_label(Device *self){ return self->volume_label; }
2089 SWIGINTERN char *Device_volume_time(Device *self){ return self->volume_time; }
2090 SWIGINTERN DeviceStatusFlags Device_status(Device *self){ return self->status; }
2091 SWIGINTERN gsize Device_min_block_size(Device *self){ return self->min_block_size; }
2092 SWIGINTERN gsize Device_max_block_size(Device *self){ return self->max_block_size; }
2093 SWIGINTERN gsize Device_block_size(Device *self){ return self->block_size; }
2094 SWIGINTERN dumpfile_t *Device_volume_header(Device *self){ return self->volume_header; }
2095
2096 SWIGINTERNINLINE SV *
2097 SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
2098 {
2099   SV *obj = sv_newmortal();
2100   sv_setiv(obj, (IV) value);
2101   return obj;
2102 }
2103
2104
2105 SWIGINTERNINLINE SV *
2106 SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
2107 {
2108   return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
2109 }
2110
2111 #ifdef __cplusplus
2112 extern "C" {
2113 #endif
2114
2115 #ifdef PERL_OBJECT
2116 #define MAGIC_CLASS _wrap_Amanda__Device_var::
2117 class _wrap_Amanda__Device_var : public CPerlObj {
2118 public:
2119 #else
2120 #define MAGIC_CLASS
2121 #endif
2122 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
2123     MAGIC_PPERL
2124     croak("Value is read-only.");
2125     return 0;
2126 }
2127
2128
2129 #ifdef PERL_OBJECT
2130 };
2131 #endif
2132
2133 #ifdef __cplusplus
2134 }
2135 #endif
2136
2137 #ifdef __cplusplus
2138 extern "C" {
2139 #endif
2140 XS(_wrap_delete_DirectTCPConnection) {
2141   {
2142     DirectTCPConnection *arg1 = (DirectTCPConnection *) 0 ;
2143     void *argp1 = 0 ;
2144     int res1 = 0 ;
2145     int argvi = 0;
2146     dXSARGS;
2147
2148     if ((items < 1) || (items > 1)) {
2149       SWIG_croak("Usage: delete_DirectTCPConnection(self);");
2150     }
2151     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_DirectTCPConnection, SWIG_POINTER_DISOWN |  0 );
2152     if (!SWIG_IsOK(res1)) {
2153       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DirectTCPConnection" "', argument " "1"" of type '" "DirectTCPConnection *""'");
2154     }
2155     arg1 = (DirectTCPConnection *)(argp1);
2156     delete_DirectTCPConnection(arg1);
2157     ST(argvi) = sv_newmortal();
2158
2159     XSRETURN(argvi);
2160   fail:
2161
2162     SWIG_croak_null();
2163   }
2164 }
2165
2166
2167 XS(_wrap_DirectTCPConnection_close) {
2168   {
2169     DirectTCPConnection *arg1 = (DirectTCPConnection *) 0 ;
2170     void *argp1 = 0 ;
2171     int res1 = 0 ;
2172     int argvi = 0;
2173     char *result = 0 ;
2174     dXSARGS;
2175
2176     if ((items < 1) || (items > 1)) {
2177       SWIG_croak("Usage: DirectTCPConnection_close(self);");
2178     }
2179     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_DirectTCPConnection, 0 |  0 );
2180     if (!SWIG_IsOK(res1)) {
2181       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirectTCPConnection_close" "', argument " "1"" of type '" "DirectTCPConnection *""'");
2182     }
2183     arg1 = (DirectTCPConnection *)(argp1);
2184     result = (char *)DirectTCPConnection_close(arg1);
2185     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2186
2187     free((char*)result);
2188     XSRETURN(argvi);
2189   fail:
2190
2191     SWIG_croak_null();
2192   }
2193 }
2194
2195
2196 XS(_wrap_new_DirectTCPConnection) {
2197   {
2198     int argvi = 0;
2199     DirectTCPConnection *result = 0 ;
2200     dXSARGS;
2201
2202     if ((items < 0) || (items > 0)) {
2203       SWIG_croak("Usage: new_DirectTCPConnection();");
2204     }
2205     result = (DirectTCPConnection *)calloc(1, sizeof(DirectTCPConnection));
2206     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirectTCPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
2207     XSRETURN(argvi);
2208   fail:
2209     SWIG_croak_null();
2210   }
2211 }
2212
2213
2214 XS(_wrap_queue_fd_t_fd_get) {
2215   {
2216     queue_fd_t *arg1 = (queue_fd_t *) 0 ;
2217     void *argp1 = 0 ;
2218     int res1 = 0 ;
2219     int argvi = 0;
2220     int result;
2221     dXSARGS;
2222
2223     if ((items < 1) || (items > 1)) {
2224       SWIG_croak("Usage: queue_fd_t_fd_get(self);");
2225     }
2226     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_queue_fd_t, 0 |  0 );
2227     if (!SWIG_IsOK(res1)) {
2228       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queue_fd_t_fd_get" "', argument " "1"" of type '" "queue_fd_t *""'");
2229     }
2230     arg1 = (queue_fd_t *)(argp1);
2231     result = (int) ((arg1)->fd);
2232     {
2233       SV *for_stack;
2234       SP += argvi; PUTBACK;
2235       for_stack = sv_2mortal(amglue_newSVi64(result));
2236       SPAGAIN; SP -= argvi;
2237       ST(argvi) = for_stack;
2238       argvi++;
2239     }
2240
2241     XSRETURN(argvi);
2242   fail:
2243
2244     SWIG_croak_null();
2245   }
2246 }
2247
2248
2249 XS(_wrap_queue_fd_t_errmsg_get) {
2250   {
2251     queue_fd_t *arg1 = (queue_fd_t *) 0 ;
2252     void *argp1 = 0 ;
2253     int res1 = 0 ;
2254     int argvi = 0;
2255     char *result = 0 ;
2256     dXSARGS;
2257
2258     if ((items < 1) || (items > 1)) {
2259       SWIG_croak("Usage: queue_fd_t_errmsg_get(self);");
2260     }
2261     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_queue_fd_t, 0 |  0 );
2262     if (!SWIG_IsOK(res1)) {
2263       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queue_fd_t_errmsg_get" "', argument " "1"" of type '" "queue_fd_t *""'");
2264     }
2265     arg1 = (queue_fd_t *)(argp1);
2266     result = (char *) ((arg1)->errmsg);
2267     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2268
2269     XSRETURN(argvi);
2270   fail:
2271
2272     SWIG_croak_null();
2273   }
2274 }
2275
2276
2277 XS(_wrap_new_queue_fd_t) {
2278   {
2279     int arg1 ;
2280     int argvi = 0;
2281     queue_fd_t *result = 0 ;
2282     dXSARGS;
2283
2284     if ((items < 1) || (items > 1)) {
2285       SWIG_croak("Usage: new_queue_fd_t(fd);");
2286     }
2287     {
2288       IO *io = NULL;
2289       PerlIO *pio = NULL;
2290       int fd = -1;
2291
2292       if (SvIOK(ST(0))) {
2293         /* plain old integer */
2294         arg1 = SvIV(ST(0));
2295       } else {
2296         /* try extracting as filehandle */
2297
2298         /* note: sv_2io may call die() */
2299         io = sv_2io(ST(0));
2300         if (io) {
2301           pio = IoIFP(io);
2302         }
2303         if (pio) {
2304           fd = PerlIO_fileno(pio);
2305         }
2306         if (fd >= 0) {
2307           arg1 = fd;
2308         } else {
2309           SWIG_exception(SWIG_TypeError, "Expected integer file descriptor "
2310             "or file handle for argument 1");
2311         }
2312       }
2313     }
2314     result = (queue_fd_t *)new_queue_fd_t(arg1);
2315     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_queue_fd_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
2316
2317     XSRETURN(argvi);
2318   fail:
2319
2320     SWIG_croak_null();
2321   }
2322 }
2323
2324
2325 XS(_wrap_delete_queue_fd_t) {
2326   {
2327     queue_fd_t *arg1 = (queue_fd_t *) 0 ;
2328     void *argp1 = 0 ;
2329     int res1 = 0 ;
2330     int argvi = 0;
2331     dXSARGS;
2332
2333     if ((items < 1) || (items > 1)) {
2334       SWIG_croak("Usage: delete_queue_fd_t(self);");
2335     }
2336     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_queue_fd_t, SWIG_POINTER_DISOWN |  0 );
2337     if (!SWIG_IsOK(res1)) {
2338       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_queue_fd_t" "', argument " "1"" of type '" "queue_fd_t *""'");
2339     }
2340     arg1 = (queue_fd_t *)(argp1);
2341     delete_queue_fd_t(arg1);
2342     ST(argvi) = sv_newmortal();
2343
2344     XSRETURN(argvi);
2345   fail:
2346
2347     SWIG_croak_null();
2348   }
2349 }
2350
2351
2352 XS(_wrap_unaliased_name) {
2353   {
2354     char *arg1 = (char *) 0 ;
2355     int res1 ;
2356     char *buf1 = 0 ;
2357     int alloc1 = 0 ;
2358     int argvi = 0;
2359     char *result = 0 ;
2360     dXSARGS;
2361
2362     if ((items < 1) || (items > 1)) {
2363       SWIG_croak("Usage: unaliased_name(char *);");
2364     }
2365     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2366     if (!SWIG_IsOK(res1)) {
2367       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unaliased_name" "', argument " "1"" of type '" "char *""'");
2368     }
2369     arg1 = (char *)(buf1);
2370     result = (char *)device_unaliased_name(arg1);
2371     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2372     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2373     XSRETURN(argvi);
2374   fail:
2375     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2376     SWIG_croak_null();
2377   }
2378 }
2379
2380
2381 XS(_wrap_new_Device) {
2382   {
2383     char *arg1 = (char *) 0 ;
2384     int res1 ;
2385     char *buf1 = 0 ;
2386     int alloc1 = 0 ;
2387     int argvi = 0;
2388     Device *result = 0 ;
2389     dXSARGS;
2390
2391     if ((items < 1) || (items > 1)) {
2392       SWIG_croak("Usage: new_Device(device_name);");
2393     }
2394     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2395     if (!SWIG_IsOK(res1)) {
2396       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Device" "', argument " "1"" of type '" "char *""'");
2397     }
2398     arg1 = (char *)(buf1);
2399     result = (Device *)new_Device(arg1);
2400     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Device, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
2401     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2402     XSRETURN(argvi);
2403   fail:
2404     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2405     SWIG_croak_null();
2406   }
2407 }
2408
2409
2410 XS(_wrap_delete_Device) {
2411   {
2412     Device *arg1 = (Device *) 0 ;
2413     void *argp1 = 0 ;
2414     int res1 = 0 ;
2415     int argvi = 0;
2416     dXSARGS;
2417
2418     if ((items < 1) || (items > 1)) {
2419       SWIG_croak("Usage: delete_Device(self);");
2420     }
2421     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, SWIG_POINTER_DISOWN |  0 );
2422     if (!SWIG_IsOK(res1)) {
2423       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Device" "', argument " "1"" of type '" "Device *""'");
2424     }
2425     arg1 = (Device *)(argp1);
2426     delete_Device(arg1);
2427     ST(argvi) = sv_newmortal();
2428
2429     XSRETURN(argvi);
2430   fail:
2431
2432     SWIG_croak_null();
2433   }
2434 }
2435
2436
2437 XS(_wrap_Device_configure) {
2438   {
2439     Device *arg1 = (Device *) 0 ;
2440     gboolean arg2 ;
2441     void *argp1 = 0 ;
2442     int res1 = 0 ;
2443     int argvi = 0;
2444     gboolean result;
2445     dXSARGS;
2446
2447     if ((items < 2) || (items > 2)) {
2448       SWIG_croak("Usage: Device_configure(self,use_global_config);");
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_configure" "', 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     result = (gboolean)Device_configure(arg1,arg2);
2469     {
2470       if (result)
2471       ST(argvi) = &PL_sv_yes;
2472       else
2473       ST(argvi) = &PL_sv_no;
2474       argvi++;
2475     }
2476
2477
2478     XSRETURN(argvi);
2479   fail:
2480
2481
2482     SWIG_croak_null();
2483   }
2484 }
2485
2486
2487 XS(_wrap_Device_error) {
2488   {
2489     Device *arg1 = (Device *) 0 ;
2490     void *argp1 = 0 ;
2491     int res1 = 0 ;
2492     int argvi = 0;
2493     char *result = 0 ;
2494     dXSARGS;
2495
2496     if ((items < 1) || (items > 1)) {
2497       SWIG_croak("Usage: Device_error(self);");
2498     }
2499     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2500     if (!SWIG_IsOK(res1)) {
2501       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_error" "', argument " "1"" of type '" "Device *""'");
2502     }
2503     arg1 = (Device *)(argp1);
2504     result = (char *)Device_error(arg1);
2505     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2506
2507     XSRETURN(argvi);
2508   fail:
2509
2510     SWIG_croak_null();
2511   }
2512 }
2513
2514
2515 XS(_wrap_Device_status_error) {
2516   {
2517     Device *arg1 = (Device *) 0 ;
2518     void *argp1 = 0 ;
2519     int res1 = 0 ;
2520     int argvi = 0;
2521     char *result = 0 ;
2522     dXSARGS;
2523
2524     if ((items < 1) || (items > 1)) {
2525       SWIG_croak("Usage: Device_status_error(self);");
2526     }
2527     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2528     if (!SWIG_IsOK(res1)) {
2529       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_status_error" "', argument " "1"" of type '" "Device *""'");
2530     }
2531     arg1 = (Device *)(argp1);
2532     result = (char *)Device_status_error(arg1);
2533     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2534
2535     XSRETURN(argvi);
2536   fail:
2537
2538     SWIG_croak_null();
2539   }
2540 }
2541
2542
2543 XS(_wrap_Device_error_or_status) {
2544   {
2545     Device *arg1 = (Device *) 0 ;
2546     void *argp1 = 0 ;
2547     int res1 = 0 ;
2548     int argvi = 0;
2549     char *result = 0 ;
2550     dXSARGS;
2551
2552     if ((items < 1) || (items > 1)) {
2553       SWIG_croak("Usage: Device_error_or_status(self);");
2554     }
2555     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2556     if (!SWIG_IsOK(res1)) {
2557       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_error_or_status" "', argument " "1"" of type '" "Device *""'");
2558     }
2559     arg1 = (Device *)(argp1);
2560     result = (char *)Device_error_or_status(arg1);
2561     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2562
2563     XSRETURN(argvi);
2564   fail:
2565
2566     SWIG_croak_null();
2567   }
2568 }
2569
2570
2571 XS(_wrap_Device_read_label) {
2572   {
2573     Device *arg1 = (Device *) 0 ;
2574     void *argp1 = 0 ;
2575     int res1 = 0 ;
2576     int argvi = 0;
2577     DeviceStatusFlags result;
2578     dXSARGS;
2579
2580     if ((items < 1) || (items > 1)) {
2581       SWIG_croak("Usage: Device_read_label(self);");
2582     }
2583     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2584     if (!SWIG_IsOK(res1)) {
2585       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_label" "', argument " "1"" of type '" "Device *""'");
2586     }
2587     arg1 = (Device *)(argp1);
2588     result = (DeviceStatusFlags)Device_read_label(arg1);
2589     {
2590       SV *for_stack;
2591       SP += argvi; PUTBACK;
2592       for_stack = sv_2mortal(amglue_newSVi64(result));
2593       SPAGAIN; SP -= argvi;
2594       ST(argvi) = for_stack;
2595       argvi++;
2596     }
2597
2598     XSRETURN(argvi);
2599   fail:
2600
2601     SWIG_croak_null();
2602   }
2603 }
2604
2605
2606 XS(_wrap_Device_start) {
2607   {
2608     Device *arg1 = (Device *) 0 ;
2609     DeviceAccessMode arg2 ;
2610     char *arg3 = (char *) 0 ;
2611     char *arg4 = (char *) 0 ;
2612     void *argp1 = 0 ;
2613     int res1 = 0 ;
2614     int res3 ;
2615     char *buf3 = 0 ;
2616     int alloc3 = 0 ;
2617     int res4 ;
2618     char *buf4 = 0 ;
2619     int alloc4 = 0 ;
2620     int argvi = 0;
2621     gboolean result;
2622     dXSARGS;
2623
2624     if ((items < 4) || (items > 4)) {
2625       SWIG_croak("Usage: Device_start(self,mode,label,timestamp);");
2626     }
2627     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2628     if (!SWIG_IsOK(res1)) {
2629       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_start" "', argument " "1"" of type '" "Device *""'");
2630     }
2631     arg1 = (Device *)(argp1);
2632     {
2633       if (sizeof(signed int) == 1) {
2634         arg2 = amglue_SvI8(ST(1));
2635       } else if (sizeof(signed int) == 2) {
2636         arg2 = amglue_SvI16(ST(1));
2637       } else if (sizeof(signed int) == 4) {
2638         arg2 = amglue_SvI32(ST(1));
2639       } else if (sizeof(signed int) == 8) {
2640         arg2 = amglue_SvI64(ST(1));
2641       } else {
2642         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2643       }
2644     }
2645     res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2646     if (!SWIG_IsOK(res3)) {
2647       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_start" "', argument " "3"" of type '" "char *""'");
2648     }
2649     arg3 = (char *)(buf3);
2650     res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
2651     if (!SWIG_IsOK(res4)) {
2652       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Device_start" "', argument " "4"" of type '" "char *""'");
2653     }
2654     arg4 = (char *)(buf4);
2655     result = (gboolean)Device_start(arg1,arg2,arg3,arg4);
2656     {
2657       if (result)
2658       ST(argvi) = &PL_sv_yes;
2659       else
2660       ST(argvi) = &PL_sv_no;
2661       argvi++;
2662     }
2663
2664
2665     if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2666     if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2667     XSRETURN(argvi);
2668   fail:
2669
2670
2671     if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2672     if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2673     SWIG_croak_null();
2674   }
2675 }
2676
2677
2678 XS(_wrap_Device_finish) {
2679   {
2680     Device *arg1 = (Device *) 0 ;
2681     void *argp1 = 0 ;
2682     int res1 = 0 ;
2683     int argvi = 0;
2684     gboolean result;
2685     dXSARGS;
2686
2687     if ((items < 1) || (items > 1)) {
2688       SWIG_croak("Usage: Device_finish(self);");
2689     }
2690     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2691     if (!SWIG_IsOK(res1)) {
2692       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_finish" "', argument " "1"" of type '" "Device *""'");
2693     }
2694     arg1 = (Device *)(argp1);
2695     result = (gboolean)Device_finish(arg1);
2696     {
2697       if (result)
2698       ST(argvi) = &PL_sv_yes;
2699       else
2700       ST(argvi) = &PL_sv_no;
2701       argvi++;
2702     }
2703
2704     XSRETURN(argvi);
2705   fail:
2706
2707     SWIG_croak_null();
2708   }
2709 }
2710
2711
2712 XS(_wrap_Device_start_file) {
2713   {
2714     Device *arg1 = (Device *) 0 ;
2715     dumpfile_t *arg2 = (dumpfile_t *) 0 ;
2716     void *argp1 = 0 ;
2717     int res1 = 0 ;
2718     void *argp2 = 0 ;
2719     int res2 = 0 ;
2720     int argvi = 0;
2721     gboolean result;
2722     dXSARGS;
2723
2724     if ((items < 2) || (items > 2)) {
2725       SWIG_croak("Usage: Device_start_file(self,jobInfo);");
2726     }
2727     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2728     if (!SWIG_IsOK(res1)) {
2729       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_start_file" "', argument " "1"" of type '" "Device *""'");
2730     }
2731     arg1 = (Device *)(argp1);
2732     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_dumpfile_t, 0 |  0 );
2733     if (!SWIG_IsOK(res2)) {
2734       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_start_file" "', argument " "2"" of type '" "dumpfile_t *""'");
2735     }
2736     arg2 = (dumpfile_t *)(argp2);
2737     result = (gboolean)Device_start_file(arg1,arg2);
2738     {
2739       if (result)
2740       ST(argvi) = &PL_sv_yes;
2741       else
2742       ST(argvi) = &PL_sv_no;
2743       argvi++;
2744     }
2745
2746
2747     XSRETURN(argvi);
2748   fail:
2749
2750
2751     SWIG_croak_null();
2752   }
2753 }
2754
2755
2756 XS(_wrap_Device_write_block) {
2757   {
2758     Device *arg1 = (Device *) 0 ;
2759     guint arg2 ;
2760     gpointer arg3 = (gpointer) 0 ;
2761     void *argp1 = 0 ;
2762     int res1 = 0 ;
2763     int res3 ;
2764     int argvi = 0;
2765     gboolean result;
2766     dXSARGS;
2767
2768     if ((items < 3) || (items > 3)) {
2769       SWIG_croak("Usage: Device_write_block(self,size,data);");
2770     }
2771     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2772     if (!SWIG_IsOK(res1)) {
2773       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_block" "', argument " "1"" of type '" "Device *""'");
2774     }
2775     arg1 = (Device *)(argp1);
2776     {
2777       if (sizeof(guint) == 1) {
2778         arg2 = amglue_SvU8(ST(1));
2779       } else if (sizeof(guint) == 2) {
2780         arg2 = amglue_SvU16(ST(1));
2781       } else if (sizeof(guint) == 4) {
2782         arg2 = amglue_SvU32(ST(1));
2783       } else if (sizeof(guint) == 8) {
2784         arg2 = amglue_SvU64(ST(1));
2785       } else {
2786         croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
2787       }
2788     }
2789     res3 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg3), 0, 0);
2790     if (!SWIG_IsOK(res3)) {
2791       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_write_block" "', argument " "3"" of type '" "gpointer""'");
2792     }
2793     result = (gboolean)Device_write_block(arg1,arg2,arg3);
2794     {
2795       if (result)
2796       ST(argvi) = &PL_sv_yes;
2797       else
2798       ST(argvi) = &PL_sv_no;
2799       argvi++;
2800     }
2801
2802
2803     XSRETURN(argvi);
2804   fail:
2805
2806
2807     SWIG_croak_null();
2808   }
2809 }
2810
2811
2812 XS(_wrap_Device_write_from_fd) {
2813   {
2814     Device *arg1 = (Device *) 0 ;
2815     queue_fd_t *arg2 = (queue_fd_t *) 0 ;
2816     void *argp1 = 0 ;
2817     int res1 = 0 ;
2818     void *argp2 = 0 ;
2819     int res2 = 0 ;
2820     int argvi = 0;
2821     gboolean result;
2822     dXSARGS;
2823
2824     if ((items < 2) || (items > 2)) {
2825       SWIG_croak("Usage: Device_write_from_fd(self,queue_fd);");
2826     }
2827     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2828     if (!SWIG_IsOK(res1)) {
2829       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_from_fd" "', argument " "1"" of type '" "Device *""'");
2830     }
2831     arg1 = (Device *)(argp1);
2832     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_queue_fd_t, 0 |  0 );
2833     if (!SWIG_IsOK(res2)) {
2834       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_write_from_fd" "', argument " "2"" of type '" "queue_fd_t *""'");
2835     }
2836     arg2 = (queue_fd_t *)(argp2);
2837     result = (gboolean)Device_write_from_fd(arg1,arg2);
2838     {
2839       if (result)
2840       ST(argvi) = &PL_sv_yes;
2841       else
2842       ST(argvi) = &PL_sv_no;
2843       argvi++;
2844     }
2845
2846
2847     XSRETURN(argvi);
2848   fail:
2849
2850
2851     SWIG_croak_null();
2852   }
2853 }
2854
2855
2856 XS(_wrap_Device_finish_file) {
2857   {
2858     Device *arg1 = (Device *) 0 ;
2859     void *argp1 = 0 ;
2860     int res1 = 0 ;
2861     int argvi = 0;
2862     gboolean result;
2863     dXSARGS;
2864
2865     if ((items < 1) || (items > 1)) {
2866       SWIG_croak("Usage: Device_finish_file(self);");
2867     }
2868     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2869     if (!SWIG_IsOK(res1)) {
2870       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_finish_file" "', argument " "1"" of type '" "Device *""'");
2871     }
2872     arg1 = (Device *)(argp1);
2873     result = (gboolean)Device_finish_file(arg1);
2874     {
2875       if (result)
2876       ST(argvi) = &PL_sv_yes;
2877       else
2878       ST(argvi) = &PL_sv_no;
2879       argvi++;
2880     }
2881
2882     XSRETURN(argvi);
2883   fail:
2884
2885     SWIG_croak_null();
2886   }
2887 }
2888
2889
2890 XS(_wrap_Device_seek_file) {
2891   {
2892     Device *arg1 = (Device *) 0 ;
2893     guint arg2 ;
2894     void *argp1 = 0 ;
2895     int res1 = 0 ;
2896     int argvi = 0;
2897     dumpfile_t *result = 0 ;
2898     dXSARGS;
2899
2900     if ((items < 2) || (items > 2)) {
2901       SWIG_croak("Usage: Device_seek_file(self,file);");
2902     }
2903     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2904     if (!SWIG_IsOK(res1)) {
2905       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_seek_file" "', argument " "1"" of type '" "Device *""'");
2906     }
2907     arg1 = (Device *)(argp1);
2908     {
2909       if (sizeof(guint) == 1) {
2910         arg2 = amglue_SvU8(ST(1));
2911       } else if (sizeof(guint) == 2) {
2912         arg2 = amglue_SvU16(ST(1));
2913       } else if (sizeof(guint) == 4) {
2914         arg2 = amglue_SvU32(ST(1));
2915       } else if (sizeof(guint) == 8) {
2916         arg2 = amglue_SvU64(ST(1));
2917       } else {
2918         croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
2919       }
2920     }
2921     result = (dumpfile_t *)Device_seek_file(arg1,arg2);
2922     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, 0 | SWIG_SHADOW); argvi++ ;
2923
2924     XSRETURN(argvi);
2925   fail:
2926
2927     SWIG_croak_null();
2928   }
2929 }
2930
2931
2932 XS(_wrap_Device_seek_block) {
2933   {
2934     Device *arg1 = (Device *) 0 ;
2935     guint64 arg2 ;
2936     void *argp1 = 0 ;
2937     int res1 = 0 ;
2938     int argvi = 0;
2939     gboolean result;
2940     dXSARGS;
2941
2942     if ((items < 2) || (items > 2)) {
2943       SWIG_croak("Usage: Device_seek_block(self,block);");
2944     }
2945     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2946     if (!SWIG_IsOK(res1)) {
2947       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_seek_block" "', argument " "1"" of type '" "Device *""'");
2948     }
2949     arg1 = (Device *)(argp1);
2950     {
2951       arg2 = amglue_SvU64(ST(1));
2952     }
2953     result = (gboolean)Device_seek_block(arg1,arg2);
2954     {
2955       if (result)
2956       ST(argvi) = &PL_sv_yes;
2957       else
2958       ST(argvi) = &PL_sv_no;
2959       argvi++;
2960     }
2961
2962     XSRETURN(argvi);
2963   fail:
2964
2965     SWIG_croak_null();
2966   }
2967 }
2968
2969
2970 XS(_wrap_Device_read_block) {
2971   {
2972     Device *arg1 = (Device *) 0 ;
2973     gpointer arg2 = (gpointer) 0 ;
2974     int *arg3 = (int *) 0 ;
2975     void *argp1 = 0 ;
2976     int res1 = 0 ;
2977     int res2 ;
2978     void *argp3 = 0 ;
2979     int res3 = 0 ;
2980     int argvi = 0;
2981     int result;
2982     dXSARGS;
2983
2984     if ((items < 3) || (items > 3)) {
2985       SWIG_croak("Usage: Device_read_block(self,buffer,size);");
2986     }
2987     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
2988     if (!SWIG_IsOK(res1)) {
2989       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_block" "', argument " "1"" of type '" "Device *""'");
2990     }
2991     arg1 = (Device *)(argp1);
2992     res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, 0);
2993     if (!SWIG_IsOK(res2)) {
2994       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_read_block" "', argument " "2"" of type '" "gpointer""'");
2995     }
2996     res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_int, 0 |  0 );
2997     if (!SWIG_IsOK(res3)) {
2998       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_read_block" "', argument " "3"" of type '" "int *""'");
2999     }
3000     arg3 = (int *)(argp3);
3001     result = (int)Device_read_block(arg1,arg2,arg3);
3002     {
3003       SV *for_stack;
3004       SP += argvi; PUTBACK;
3005       for_stack = sv_2mortal(amglue_newSVi64(result));
3006       SPAGAIN; SP -= argvi;
3007       ST(argvi) = for_stack;
3008       argvi++;
3009     }
3010
3011
3012
3013     XSRETURN(argvi);
3014   fail:
3015
3016
3017
3018     SWIG_croak_null();
3019   }
3020 }
3021
3022
3023 XS(_wrap_Device_read_to_fd) {
3024   {
3025     Device *arg1 = (Device *) 0 ;
3026     queue_fd_t *arg2 = (queue_fd_t *) 0 ;
3027     void *argp1 = 0 ;
3028     int res1 = 0 ;
3029     void *argp2 = 0 ;
3030     int res2 = 0 ;
3031     int argvi = 0;
3032     gboolean result;
3033     dXSARGS;
3034
3035     if ((items < 2) || (items > 2)) {
3036       SWIG_croak("Usage: Device_read_to_fd(self,queue_fd);");
3037     }
3038     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3039     if (!SWIG_IsOK(res1)) {
3040       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_to_fd" "', argument " "1"" of type '" "Device *""'");
3041     }
3042     arg1 = (Device *)(argp1);
3043     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_queue_fd_t, 0 |  0 );
3044     if (!SWIG_IsOK(res2)) {
3045       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_read_to_fd" "', argument " "2"" of type '" "queue_fd_t *""'");
3046     }
3047     arg2 = (queue_fd_t *)(argp2);
3048     result = (gboolean)Device_read_to_fd(arg1,arg2);
3049     {
3050       if (result)
3051       ST(argvi) = &PL_sv_yes;
3052       else
3053       ST(argvi) = &PL_sv_no;
3054       argvi++;
3055     }
3056
3057
3058     XSRETURN(argvi);
3059   fail:
3060
3061
3062     SWIG_croak_null();
3063   }
3064 }
3065
3066
3067 XS(_wrap_Device_erase) {
3068   {
3069     Device *arg1 = (Device *) 0 ;
3070     void *argp1 = 0 ;
3071     int res1 = 0 ;
3072     int argvi = 0;
3073     gboolean result;
3074     dXSARGS;
3075
3076     if ((items < 1) || (items > 1)) {
3077       SWIG_croak("Usage: Device_erase(self);");
3078     }
3079     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3080     if (!SWIG_IsOK(res1)) {
3081       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_erase" "', argument " "1"" of type '" "Device *""'");
3082     }
3083     arg1 = (Device *)(argp1);
3084     result = (gboolean)Device_erase(arg1);
3085     {
3086       if (result)
3087       ST(argvi) = &PL_sv_yes;
3088       else
3089       ST(argvi) = &PL_sv_no;
3090       argvi++;
3091     }
3092
3093     XSRETURN(argvi);
3094   fail:
3095
3096     SWIG_croak_null();
3097   }
3098 }
3099
3100
3101 XS(_wrap_Device_eject) {
3102   {
3103     Device *arg1 = (Device *) 0 ;
3104     void *argp1 = 0 ;
3105     int res1 = 0 ;
3106     int argvi = 0;
3107     gboolean result;
3108     dXSARGS;
3109
3110     if ((items < 1) || (items > 1)) {
3111       SWIG_croak("Usage: Device_eject(self);");
3112     }
3113     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3114     if (!SWIG_IsOK(res1)) {
3115       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_eject" "', argument " "1"" of type '" "Device *""'");
3116     }
3117     arg1 = (Device *)(argp1);
3118     result = (gboolean)Device_eject(arg1);
3119     {
3120       if (result)
3121       ST(argvi) = &PL_sv_yes;
3122       else
3123       ST(argvi) = &PL_sv_no;
3124       argvi++;
3125     }
3126
3127     XSRETURN(argvi);
3128   fail:
3129
3130     SWIG_croak_null();
3131   }
3132 }
3133
3134
3135 XS(_wrap_Device_directtcp_supported) {
3136   {
3137     Device *arg1 = (Device *) 0 ;
3138     void *argp1 = 0 ;
3139     int res1 = 0 ;
3140     int argvi = 0;
3141     gboolean result;
3142     dXSARGS;
3143
3144     if ((items < 1) || (items > 1)) {
3145       SWIG_croak("Usage: Device_directtcp_supported(self);");
3146     }
3147     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3148     if (!SWIG_IsOK(res1)) {
3149       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_directtcp_supported" "', argument " "1"" of type '" "Device *""'");
3150     }
3151     arg1 = (Device *)(argp1);
3152     result = (gboolean)Device_directtcp_supported(arg1);
3153     {
3154       if (result)
3155       ST(argvi) = &PL_sv_yes;
3156       else
3157       ST(argvi) = &PL_sv_no;
3158       argvi++;
3159     }
3160
3161     XSRETURN(argvi);
3162   fail:
3163
3164     SWIG_croak_null();
3165   }
3166 }
3167
3168
3169 XS(_wrap_Device_listen) {
3170   {
3171     Device *arg1 = (Device *) 0 ;
3172     gboolean arg2 ;
3173     DirectTCPAddr **arg3 = (DirectTCPAddr **) 0 ;
3174     void *argp1 = 0 ;
3175     int res1 = 0 ;
3176     DirectTCPAddr *addrs3 ;
3177     int argvi = 0;
3178     dXSARGS;
3179
3180     {
3181       addrs3 = NULL;
3182       arg3 = &addrs3;
3183     }
3184     if ((items < 2) || (items > 2)) {
3185       SWIG_croak("Usage: Device_listen(self,for_writing);");
3186     }
3187     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3188     if (!SWIG_IsOK(res1)) {
3189       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_listen" "', argument " "1"" of type '" "Device *""'");
3190     }
3191     arg1 = (Device *)(argp1);
3192     {
3193       if (sizeof(signed int) == 1) {
3194         arg2 = amglue_SvI8(ST(1));
3195       } else if (sizeof(signed int) == 2) {
3196         arg2 = amglue_SvI16(ST(1));
3197       } else if (sizeof(signed int) == 4) {
3198         arg2 = amglue_SvI32(ST(1));
3199       } else if (sizeof(signed int) == 8) {
3200         arg2 = amglue_SvI64(ST(1));
3201       } else {
3202         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3203       }
3204     }
3205     Device_listen(arg1,arg2,arg3);
3206     ST(argvi) = sv_newmortal();
3207     {
3208       if (arg3 && *arg3) {
3209         DirectTCPAddr *iter = *arg3;
3210         AV *av = newAV();
3211         int i = 0;
3212
3213         while (iter && iter->ipv4) {
3214           struct in_addr in;
3215           char *addr;
3216           AV *tuple = newAV();
3217
3218           in.s_addr = htonl(iter->ipv4);
3219           addr = inet_ntoa(in);
3220           g_assert(NULL != av_store(tuple, 0,
3221               newSVpv(addr, 0)));
3222           g_assert(NULL != av_store(tuple, 1, newSViv(iter->port)));
3223           g_assert(NULL != av_store(av, i++, newRV_noinc((SV *)tuple)));
3224           iter++;
3225         }
3226
3227         ST(argvi) = newRV_noinc((SV *)av);
3228         argvi++;
3229       }
3230     }
3231
3232
3233
3234     XSRETURN(argvi);
3235   fail:
3236
3237
3238
3239     SWIG_croak_null();
3240   }
3241 }
3242
3243
3244 XS(_wrap_Device_accept) {
3245   {
3246     Device *arg1 = (Device *) 0 ;
3247     void *argp1 = 0 ;
3248     int res1 = 0 ;
3249     int argvi = 0;
3250     DirectTCPConnection *result = 0 ;
3251     dXSARGS;
3252
3253     if ((items < 1) || (items > 1)) {
3254       SWIG_croak("Usage: Device_accept(self);");
3255     }
3256     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3257     if (!SWIG_IsOK(res1)) {
3258       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_accept" "', argument " "1"" of type '" "Device *""'");
3259     }
3260     arg1 = (Device *)(argp1);
3261     result = (DirectTCPConnection *)Device_accept(arg1);
3262     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirectTCPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3263
3264     XSRETURN(argvi);
3265   fail:
3266
3267     SWIG_croak_null();
3268   }
3269 }
3270
3271
3272 XS(_wrap_Device_use_connection) {
3273   {
3274     Device *arg1 = (Device *) 0 ;
3275     DirectTCPConnection *arg2 = (DirectTCPConnection *) 0 ;
3276     void *argp1 = 0 ;
3277     int res1 = 0 ;
3278     void *argp2 = 0 ;
3279     int res2 = 0 ;
3280     int argvi = 0;
3281     gboolean result;
3282     dXSARGS;
3283
3284     if ((items < 2) || (items > 2)) {
3285       SWIG_croak("Usage: Device_use_connection(self,conn);");
3286     }
3287     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3288     if (!SWIG_IsOK(res1)) {
3289       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_use_connection" "', argument " "1"" of type '" "Device *""'");
3290     }
3291     arg1 = (Device *)(argp1);
3292     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_DirectTCPConnection, 0 |  0 );
3293     if (!SWIG_IsOK(res2)) {
3294       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_use_connection" "', argument " "2"" of type '" "DirectTCPConnection *""'");
3295     }
3296     arg2 = (DirectTCPConnection *)(argp2);
3297     result = (gboolean)Device_use_connection(arg1,arg2);
3298     {
3299       if (result)
3300       ST(argvi) = &PL_sv_yes;
3301       else
3302       ST(argvi) = &PL_sv_no;
3303       argvi++;
3304     }
3305
3306
3307     XSRETURN(argvi);
3308   fail:
3309
3310
3311     SWIG_croak_null();
3312   }
3313 }
3314
3315
3316 XS(_wrap_Device_write_from_connection) {
3317   {
3318     Device *arg1 = (Device *) 0 ;
3319     guint64 arg2 ;
3320     guint64 *arg3 = (guint64 *) 0 ;
3321     void *argp1 = 0 ;
3322     int res1 = 0 ;
3323     guint64 sz3 ;
3324     int argvi = 0;
3325     gboolean result;
3326     dXSARGS;
3327
3328     {
3329       sz3 = 0;
3330       arg3 = &sz3;
3331     }
3332     if ((items < 2) || (items > 2)) {
3333       SWIG_croak("Usage: Device_write_from_connection(self,size);");
3334     }
3335     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3336     if (!SWIG_IsOK(res1)) {
3337       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_from_connection" "', argument " "1"" of type '" "Device *""'");
3338     }
3339     arg1 = (Device *)(argp1);
3340     {
3341       arg2 = amglue_SvU64(ST(1));
3342     }
3343     result = (gboolean)Device_write_from_connection(arg1,arg2,arg3);
3344     {
3345       if (result)
3346       ST(argvi) = &PL_sv_yes;
3347       else
3348       ST(argvi) = &PL_sv_no;
3349       argvi++;
3350     }
3351     {
3352       SP += argvi; PUTBACK;
3353       ST(argvi) = sv_2mortal(amglue_newSVu64(*arg3));
3354       SPAGAIN; SP -= argvi; argvi++;
3355     }
3356
3357
3358     XSRETURN(argvi);
3359   fail:
3360
3361
3362     SWIG_croak_null();
3363   }
3364 }
3365
3366
3367 XS(_wrap_Device_read_to_connection) {
3368   {
3369     Device *arg1 = (Device *) 0 ;
3370     guint64 arg2 ;
3371     guint64 *arg3 = (guint64 *) 0 ;
3372     void *argp1 = 0 ;
3373     int res1 = 0 ;
3374     guint64 sz3 ;
3375     int argvi = 0;
3376     gboolean result;
3377     dXSARGS;
3378
3379     {
3380       sz3 = 0;
3381       arg3 = &sz3;
3382     }
3383     if ((items < 2) || (items > 2)) {
3384       SWIG_croak("Usage: Device_read_to_connection(self,size);");
3385     }
3386     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3387     if (!SWIG_IsOK(res1)) {
3388       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_to_connection" "', argument " "1"" of type '" "Device *""'");
3389     }
3390     arg1 = (Device *)(argp1);
3391     {
3392       arg2 = amglue_SvU64(ST(1));
3393     }
3394     result = (gboolean)Device_read_to_connection(arg1,arg2,arg3);
3395     {
3396       if (result)
3397       ST(argvi) = &PL_sv_yes;
3398       else
3399       ST(argvi) = &PL_sv_no;
3400       argvi++;
3401     }
3402     {
3403       SP += argvi; PUTBACK;
3404       ST(argvi) = sv_2mortal(amglue_newSVu64(*arg3));
3405       SPAGAIN; SP -= argvi; argvi++;
3406     }
3407
3408
3409     XSRETURN(argvi);
3410   fail:
3411
3412
3413     SWIG_croak_null();
3414   }
3415 }
3416
3417
3418 XS(_wrap_Device_property_list) {
3419   {
3420     Device *arg1 = (Device *) 0 ;
3421     void *argp1 = 0 ;
3422     int res1 = 0 ;
3423     int argvi = 0;
3424     GSList *result = 0 ;
3425     dXSARGS;
3426
3427     if ((items < 1) || (items > 1)) {
3428       SWIG_croak("Usage: Device_property_list(self);");
3429     }
3430     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3431     if (!SWIG_IsOK(res1)) {
3432       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_list" "', argument " "1"" of type '" "Device *""'");
3433     }
3434     arg1 = (Device *)(argp1);
3435     result = (GSList *)Device_property_list(arg1);
3436     {
3437       GSList *iter;
3438
3439       /* Count the DeviceProperties */
3440       EXTEND(SP, g_slist_length(result)); /* make room for return values */
3441
3442       /* Note that we set ST(argvi) several times. the nature of
3443              * SWIG's wrapping is such that incrementing argvi points
3444              * ST(argvi) to the next location in perl's argument stack.
3445                    */
3446
3447       for (iter = result; iter; iter = g_slist_next(iter)) {
3448         DeviceProperty *prop = iter->data;
3449         HV *hash = newHV();
3450         SV *rv = newRV_noinc((SV *)hash);
3451
3452         hv_store(hash, "name", 4,
3453           newSVpv(prop->base->name, 0), 0);
3454         hv_store(hash, "description", 11,
3455           newSVpv(prop->base->description, 0), 0);
3456         hv_store(hash, "access", 6,
3457           newSViv(prop->access), 0);
3458         ST(argvi) = sv_2mortal(rv);
3459         argvi++;
3460       }
3461     }
3462
3463     XSRETURN(argvi);
3464   fail:
3465
3466     SWIG_croak_null();
3467   }
3468 }
3469
3470
3471 XS(_wrap_Device_property_get) {
3472   {
3473     Device *arg1 = (Device *) 0 ;
3474     DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
3475     GValue *arg3 = (GValue *) 0 ;
3476     PropertySurety *arg4 = (PropertySurety *) 0 ;
3477     PropertySource *arg5 = (PropertySource *) 0 ;
3478     gboolean *arg6 = (gboolean *) 0 ;
3479     void *argp1 = 0 ;
3480     int res1 = 0 ;
3481     GValue val3 ;
3482     PropertySurety surety3 ;
3483     PropertySource source3 ;
3484     gboolean found3 ;
3485     int argvi = 0;
3486     dXSARGS;
3487
3488     {
3489       memset(&val3, 0, sizeof(val3));
3490       arg3 = &val3;
3491       if (GIMME_V == G_ARRAY) {
3492         arg4 = &surety3;
3493         arg5 = &source3;
3494       }
3495       arg6 = &found3;
3496     }
3497     if ((items < 2) || (items > 2)) {
3498       SWIG_croak("Usage: Device_property_get(self,pbase,surety,source,val_found);");
3499     }
3500     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3501     if (!SWIG_IsOK(res1)) {
3502       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_get" "', argument " "1"" of type '" "Device *""'");
3503     }
3504     arg1 = (Device *)(argp1);
3505     {
3506       char *pname = NULL;
3507
3508       if (SvPOK(ST(1)))
3509       pname = SvPV_nolen(ST(1));
3510
3511       if (pname) arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
3512       if (!pname || !arg2) {
3513         SWIG_exception_fail(SWIG_ValueError, "Invalid property name");
3514       }
3515     }
3516     Device_property_get(arg1,arg2,arg3,arg4,arg5,arg6);
3517     ST(argvi) = sv_newmortal();
3518     {
3519       /* if the result is valid */
3520       if (*arg6) {
3521         /* move data from arg3 to ST(argvi), somehow, being careful to
3522                          * save the perl stack while doing so */
3523         SP += argvi; PUTBACK;
3524         ST(argvi) = set_sv_from_gvalue(arg3);
3525         SPAGAIN; SP -= argvi; argvi++;
3526
3527         /* free any memory for the GValue */
3528         g_value_unset(arg3);
3529
3530         if (GIMME_V == G_ARRAY) {
3531           ST(argvi) = newSViv(*arg4);
3532           argvi++;
3533           ST(argvi) = newSViv(*arg5);
3534           argvi++;
3535         }
3536       }
3537       /* otherwise, return nothing */
3538     }
3539
3540
3541     XSRETURN(argvi);
3542   fail:
3543
3544
3545     SWIG_croak_null();
3546   }
3547 }
3548
3549
3550 XS(_wrap_Device_property_set) {
3551   {
3552     Device *arg1 = (Device *) 0 ;
3553     DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
3554     SV *arg3 = (SV *) 0 ;
3555     void *argp1 = 0 ;
3556     int res1 = 0 ;
3557     int argvi = 0;
3558     gboolean result;
3559     dXSARGS;
3560
3561     if ((items < 3) || (items > 3)) {
3562       SWIG_croak("Usage: Device_property_set(self,pbase,sv);");
3563     }
3564     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3565     if (!SWIG_IsOK(res1)) {
3566       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_set" "', argument " "1"" of type '" "Device *""'");
3567     }
3568     arg1 = (Device *)(argp1);
3569     {
3570       char *pname = NULL;
3571
3572       if (SvPOK(ST(1)))
3573       pname = SvPV_nolen(ST(1));
3574
3575       if (pname) arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
3576       if (!pname || !arg2) {
3577         SWIG_exception_fail(SWIG_ValueError, "Invalid property name");
3578       }
3579     }
3580     arg3 = ST(2);
3581     result = (gboolean)Device_property_set(arg1,arg2,arg3);
3582     {
3583       if (result)
3584       ST(argvi) = &PL_sv_yes;
3585       else
3586       ST(argvi) = &PL_sv_no;
3587       argvi++;
3588     }
3589
3590
3591
3592     XSRETURN(argvi);
3593   fail:
3594
3595
3596
3597     SWIG_croak_null();
3598   }
3599 }
3600
3601
3602 XS(_wrap_Device_property_set_ex) {
3603   {
3604     Device *arg1 = (Device *) 0 ;
3605     DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
3606     SV *arg3 = (SV *) 0 ;
3607     PropertySurety arg4 ;
3608     PropertySource arg5 ;
3609     void *argp1 = 0 ;
3610     int res1 = 0 ;
3611     int argvi = 0;
3612     gboolean result;
3613     dXSARGS;
3614
3615     if ((items < 5) || (items > 5)) {
3616       SWIG_croak("Usage: Device_property_set_ex(self,pbase,sv,surety,source);");
3617     }
3618     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3619     if (!SWIG_IsOK(res1)) {
3620       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_set_ex" "', argument " "1"" of type '" "Device *""'");
3621     }
3622     arg1 = (Device *)(argp1);
3623     {
3624       char *pname = NULL;
3625
3626       if (SvPOK(ST(1)))
3627       pname = SvPV_nolen(ST(1));
3628
3629       if (pname) arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
3630       if (!pname || !arg2) {
3631         SWIG_exception_fail(SWIG_ValueError, "Invalid property name");
3632       }
3633     }
3634     arg3 = ST(2);
3635     {
3636       if (sizeof(signed int) == 1) {
3637         arg4 = amglue_SvI8(ST(3));
3638       } else if (sizeof(signed int) == 2) {
3639         arg4 = amglue_SvI16(ST(3));
3640       } else if (sizeof(signed int) == 4) {
3641         arg4 = amglue_SvI32(ST(3));
3642       } else if (sizeof(signed int) == 8) {
3643         arg4 = amglue_SvI64(ST(3));
3644       } else {
3645         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3646       }
3647     }
3648     {
3649       if (sizeof(signed int) == 1) {
3650         arg5 = amglue_SvI8(ST(4));
3651       } else if (sizeof(signed int) == 2) {
3652         arg5 = amglue_SvI16(ST(4));
3653       } else if (sizeof(signed int) == 4) {
3654         arg5 = amglue_SvI32(ST(4));
3655       } else if (sizeof(signed int) == 8) {
3656         arg5 = amglue_SvI64(ST(4));
3657       } else {
3658         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3659       }
3660     }
3661     result = (gboolean)Device_property_set_ex(arg1,arg2,arg3,arg4,arg5);
3662     {
3663       if (result)
3664       ST(argvi) = &PL_sv_yes;
3665       else
3666       ST(argvi) = &PL_sv_no;
3667       argvi++;
3668     }
3669
3670
3671
3672
3673
3674     XSRETURN(argvi);
3675   fail:
3676
3677
3678
3679
3680
3681     SWIG_croak_null();
3682   }
3683 }
3684
3685
3686 XS(_wrap_Device_recycle_file) {
3687   {
3688     Device *arg1 = (Device *) 0 ;
3689     guint arg2 ;
3690     void *argp1 = 0 ;
3691     int res1 = 0 ;
3692     int argvi = 0;
3693     gboolean result;
3694     dXSARGS;
3695
3696     if ((items < 2) || (items > 2)) {
3697       SWIG_croak("Usage: Device_recycle_file(self,filenum);");
3698     }
3699     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3700     if (!SWIG_IsOK(res1)) {
3701       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_recycle_file" "', argument " "1"" of type '" "Device *""'");
3702     }
3703     arg1 = (Device *)(argp1);
3704     {
3705       if (sizeof(guint) == 1) {
3706         arg2 = amglue_SvU8(ST(1));
3707       } else if (sizeof(guint) == 2) {
3708         arg2 = amglue_SvU16(ST(1));
3709       } else if (sizeof(guint) == 4) {
3710         arg2 = amglue_SvU32(ST(1));
3711       } else if (sizeof(guint) == 8) {
3712         arg2 = amglue_SvU64(ST(1));
3713       } else {
3714         croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
3715       }
3716     }
3717     result = (gboolean)Device_recycle_file(arg1,arg2);
3718     {
3719       if (result)
3720       ST(argvi) = &PL_sv_yes;
3721       else
3722       ST(argvi) = &PL_sv_no;
3723       argvi++;
3724     }
3725
3726     XSRETURN(argvi);
3727   fail:
3728
3729     SWIG_croak_null();
3730   }
3731 }
3732
3733
3734 XS(_wrap_Device_file) {
3735   {
3736     Device *arg1 = (Device *) 0 ;
3737     void *argp1 = 0 ;
3738     int res1 = 0 ;
3739     int argvi = 0;
3740     int result;
3741     dXSARGS;
3742
3743     if ((items < 1) || (items > 1)) {
3744       SWIG_croak("Usage: Device_file(self);");
3745     }
3746     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3747     if (!SWIG_IsOK(res1)) {
3748       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_file" "', argument " "1"" of type '" "Device *""'");
3749     }
3750     arg1 = (Device *)(argp1);
3751     result = (int)Device_file(arg1);
3752     {
3753       SV *for_stack;
3754       SP += argvi; PUTBACK;
3755       for_stack = sv_2mortal(amglue_newSVi64(result));
3756       SPAGAIN; SP -= argvi;
3757       ST(argvi) = for_stack;
3758       argvi++;
3759     }
3760
3761     XSRETURN(argvi);
3762   fail:
3763
3764     SWIG_croak_null();
3765   }
3766 }
3767
3768
3769 XS(_wrap_Device_block) {
3770   {
3771     Device *arg1 = (Device *) 0 ;
3772     void *argp1 = 0 ;
3773     int res1 = 0 ;
3774     int argvi = 0;
3775     guint64 result;
3776     dXSARGS;
3777
3778     if ((items < 1) || (items > 1)) {
3779       SWIG_croak("Usage: Device_block(self);");
3780     }
3781     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3782     if (!SWIG_IsOK(res1)) {
3783       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_block" "', argument " "1"" of type '" "Device *""'");
3784     }
3785     arg1 = (Device *)(argp1);
3786     result = Device_block(arg1);
3787     {
3788       SV *for_stack;
3789       SP += argvi; PUTBACK;
3790       for_stack = sv_2mortal(amglue_newSVu64(result));
3791       SPAGAIN; SP -= argvi;
3792       ST(argvi) = for_stack;
3793       argvi++;
3794     }
3795
3796     XSRETURN(argvi);
3797   fail:
3798
3799     SWIG_croak_null();
3800   }
3801 }
3802
3803
3804 XS(_wrap_Device_in_file) {
3805   {
3806     Device *arg1 = (Device *) 0 ;
3807     void *argp1 = 0 ;
3808     int res1 = 0 ;
3809     int argvi = 0;
3810     gboolean result;
3811     dXSARGS;
3812
3813     if ((items < 1) || (items > 1)) {
3814       SWIG_croak("Usage: Device_in_file(self);");
3815     }
3816     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3817     if (!SWIG_IsOK(res1)) {
3818       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_in_file" "', argument " "1"" of type '" "Device *""'");
3819     }
3820     arg1 = (Device *)(argp1);
3821     result = (gboolean)Device_in_file(arg1);
3822     {
3823       if (result)
3824       ST(argvi) = &PL_sv_yes;
3825       else
3826       ST(argvi) = &PL_sv_no;
3827       argvi++;
3828     }
3829
3830     XSRETURN(argvi);
3831   fail:
3832
3833     SWIG_croak_null();
3834   }
3835 }
3836
3837
3838 XS(_wrap_Device_device_name) {
3839   {
3840     Device *arg1 = (Device *) 0 ;
3841     void *argp1 = 0 ;
3842     int res1 = 0 ;
3843     int argvi = 0;
3844     char *result = 0 ;
3845     dXSARGS;
3846
3847     if ((items < 1) || (items > 1)) {
3848       SWIG_croak("Usage: Device_device_name(self);");
3849     }
3850     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3851     if (!SWIG_IsOK(res1)) {
3852       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_device_name" "', argument " "1"" of type '" "Device *""'");
3853     }
3854     arg1 = (Device *)(argp1);
3855     result = (char *)Device_device_name(arg1);
3856     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3857
3858     XSRETURN(argvi);
3859   fail:
3860
3861     SWIG_croak_null();
3862   }
3863 }
3864
3865
3866 XS(_wrap_Device_access_mode) {
3867   {
3868     Device *arg1 = (Device *) 0 ;
3869     void *argp1 = 0 ;
3870     int res1 = 0 ;
3871     int argvi = 0;
3872     DeviceAccessMode result;
3873     dXSARGS;
3874
3875     if ((items < 1) || (items > 1)) {
3876       SWIG_croak("Usage: Device_access_mode(self);");
3877     }
3878     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3879     if (!SWIG_IsOK(res1)) {
3880       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_access_mode" "', argument " "1"" of type '" "Device *""'");
3881     }
3882     arg1 = (Device *)(argp1);
3883     result = (DeviceAccessMode)Device_access_mode(arg1);
3884     {
3885       SV *for_stack;
3886       SP += argvi; PUTBACK;
3887       for_stack = sv_2mortal(amglue_newSVi64(result));
3888       SPAGAIN; SP -= argvi;
3889       ST(argvi) = for_stack;
3890       argvi++;
3891     }
3892
3893     XSRETURN(argvi);
3894   fail:
3895
3896     SWIG_croak_null();
3897   }
3898 }
3899
3900
3901 XS(_wrap_Device_is_eof) {
3902   {
3903     Device *arg1 = (Device *) 0 ;
3904     void *argp1 = 0 ;
3905     int res1 = 0 ;
3906     int argvi = 0;
3907     gboolean result;
3908     dXSARGS;
3909
3910     if ((items < 1) || (items > 1)) {
3911       SWIG_croak("Usage: Device_is_eof(self);");
3912     }
3913     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3914     if (!SWIG_IsOK(res1)) {
3915       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_is_eof" "', argument " "1"" of type '" "Device *""'");
3916     }
3917     arg1 = (Device *)(argp1);
3918     result = (gboolean)Device_is_eof(arg1);
3919     {
3920       if (result)
3921       ST(argvi) = &PL_sv_yes;
3922       else
3923       ST(argvi) = &PL_sv_no;
3924       argvi++;
3925     }
3926
3927     XSRETURN(argvi);
3928   fail:
3929
3930     SWIG_croak_null();
3931   }
3932 }
3933
3934
3935 XS(_wrap_Device_is_eom) {
3936   {
3937     Device *arg1 = (Device *) 0 ;
3938     void *argp1 = 0 ;
3939     int res1 = 0 ;
3940     int argvi = 0;
3941     gboolean result;
3942     dXSARGS;
3943
3944     if ((items < 1) || (items > 1)) {
3945       SWIG_croak("Usage: Device_is_eom(self);");
3946     }
3947     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3948     if (!SWIG_IsOK(res1)) {
3949       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_is_eom" "', argument " "1"" of type '" "Device *""'");
3950     }
3951     arg1 = (Device *)(argp1);
3952     result = (gboolean)Device_is_eom(arg1);
3953     {
3954       if (result)
3955       ST(argvi) = &PL_sv_yes;
3956       else
3957       ST(argvi) = &PL_sv_no;
3958       argvi++;
3959     }
3960
3961     XSRETURN(argvi);
3962   fail:
3963
3964     SWIG_croak_null();
3965   }
3966 }
3967
3968
3969 XS(_wrap_Device_volume_label) {
3970   {
3971     Device *arg1 = (Device *) 0 ;
3972     void *argp1 = 0 ;
3973     int res1 = 0 ;
3974     int argvi = 0;
3975     char *result = 0 ;
3976     dXSARGS;
3977
3978     if ((items < 1) || (items > 1)) {
3979       SWIG_croak("Usage: Device_volume_label(self);");
3980     }
3981     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
3982     if (!SWIG_IsOK(res1)) {
3983       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_label" "', argument " "1"" of type '" "Device *""'");
3984     }
3985     arg1 = (Device *)(argp1);
3986     result = (char *)Device_volume_label(arg1);
3987     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3988
3989     XSRETURN(argvi);
3990   fail:
3991
3992     SWIG_croak_null();
3993   }
3994 }
3995
3996
3997 XS(_wrap_Device_volume_time) {
3998   {
3999     Device *arg1 = (Device *) 0 ;
4000     void *argp1 = 0 ;
4001     int res1 = 0 ;
4002     int argvi = 0;
4003     char *result = 0 ;
4004     dXSARGS;
4005
4006     if ((items < 1) || (items > 1)) {
4007       SWIG_croak("Usage: Device_volume_time(self);");
4008     }
4009     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
4010     if (!SWIG_IsOK(res1)) {
4011       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_time" "', argument " "1"" of type '" "Device *""'");
4012     }
4013     arg1 = (Device *)(argp1);
4014     result = (char *)Device_volume_time(arg1);
4015     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4016
4017     XSRETURN(argvi);
4018   fail:
4019
4020     SWIG_croak_null();
4021   }
4022 }
4023
4024
4025 XS(_wrap_Device_status) {
4026   {
4027     Device *arg1 = (Device *) 0 ;
4028     void *argp1 = 0 ;
4029     int res1 = 0 ;
4030     int argvi = 0;
4031     DeviceStatusFlags result;
4032     dXSARGS;
4033
4034     if ((items < 1) || (items > 1)) {
4035       SWIG_croak("Usage: Device_status(self);");
4036     }
4037     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
4038     if (!SWIG_IsOK(res1)) {
4039       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_status" "', argument " "1"" of type '" "Device *""'");
4040     }
4041     arg1 = (Device *)(argp1);
4042     result = (DeviceStatusFlags)Device_status(arg1);
4043     {
4044       SV *for_stack;
4045       SP += argvi; PUTBACK;
4046       for_stack = sv_2mortal(amglue_newSVi64(result));
4047       SPAGAIN; SP -= argvi;
4048       ST(argvi) = for_stack;
4049       argvi++;
4050     }
4051
4052     XSRETURN(argvi);
4053   fail:
4054
4055     SWIG_croak_null();
4056   }
4057 }
4058
4059
4060 XS(_wrap_Device_min_block_size) {
4061   {
4062     Device *arg1 = (Device *) 0 ;
4063     void *argp1 = 0 ;
4064     int res1 = 0 ;
4065     int argvi = 0;
4066     gsize result;
4067     dXSARGS;
4068
4069     if ((items < 1) || (items > 1)) {
4070       SWIG_croak("Usage: Device_min_block_size(self);");
4071     }
4072     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
4073     if (!SWIG_IsOK(res1)) {
4074       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_min_block_size" "', argument " "1"" of type '" "Device *""'");
4075     }
4076     arg1 = (Device *)(argp1);
4077     result = Device_min_block_size(arg1);
4078     {
4079       SV *for_stack;
4080       SP += argvi; PUTBACK;
4081       for_stack = sv_2mortal(amglue_newSVu64(result));
4082       SPAGAIN; SP -= argvi;
4083       ST(argvi) = for_stack;
4084       argvi++;
4085     }
4086
4087     XSRETURN(argvi);
4088   fail:
4089
4090     SWIG_croak_null();
4091   }
4092 }
4093
4094
4095 XS(_wrap_Device_max_block_size) {
4096   {
4097     Device *arg1 = (Device *) 0 ;
4098     void *argp1 = 0 ;
4099     int res1 = 0 ;
4100     int argvi = 0;
4101     gsize result;
4102     dXSARGS;
4103
4104     if ((items < 1) || (items > 1)) {
4105       SWIG_croak("Usage: Device_max_block_size(self);");
4106     }
4107     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
4108     if (!SWIG_IsOK(res1)) {
4109       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_max_block_size" "', argument " "1"" of type '" "Device *""'");
4110     }
4111     arg1 = (Device *)(argp1);
4112     result = Device_max_block_size(arg1);
4113     {
4114       SV *for_stack;
4115       SP += argvi; PUTBACK;
4116       for_stack = sv_2mortal(amglue_newSVu64(result));
4117       SPAGAIN; SP -= argvi;
4118       ST(argvi) = for_stack;
4119       argvi++;
4120     }
4121
4122     XSRETURN(argvi);
4123   fail:
4124
4125     SWIG_croak_null();
4126   }
4127 }
4128
4129
4130 XS(_wrap_Device_block_size) {
4131   {
4132     Device *arg1 = (Device *) 0 ;
4133     void *argp1 = 0 ;
4134     int res1 = 0 ;
4135     int argvi = 0;
4136     gsize result;
4137     dXSARGS;
4138
4139     if ((items < 1) || (items > 1)) {
4140       SWIG_croak("Usage: Device_block_size(self);");
4141     }
4142     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
4143     if (!SWIG_IsOK(res1)) {
4144       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_block_size" "', argument " "1"" of type '" "Device *""'");
4145     }
4146     arg1 = (Device *)(argp1);
4147     result = Device_block_size(arg1);
4148     {
4149       SV *for_stack;
4150       SP += argvi; PUTBACK;
4151       for_stack = sv_2mortal(amglue_newSVu64(result));
4152       SPAGAIN; SP -= argvi;
4153       ST(argvi) = for_stack;
4154       argvi++;
4155     }
4156
4157     XSRETURN(argvi);
4158   fail:
4159
4160     SWIG_croak_null();
4161   }
4162 }
4163
4164
4165 XS(_wrap_Device_volume_header) {
4166   {
4167     Device *arg1 = (Device *) 0 ;
4168     void *argp1 = 0 ;
4169     int res1 = 0 ;
4170     int argvi = 0;
4171     dumpfile_t *result = 0 ;
4172     dXSARGS;
4173
4174     if ((items < 1) || (items > 1)) {
4175       SWIG_croak("Usage: Device_volume_header(self);");
4176     }
4177     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
4178     if (!SWIG_IsOK(res1)) {
4179       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_header" "', argument " "1"" of type '" "Device *""'");
4180     }
4181     arg1 = (Device *)(argp1);
4182     result = (dumpfile_t *)Device_volume_header(arg1);
4183     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, 0 | SWIG_SHADOW); argvi++ ;
4184
4185     XSRETURN(argvi);
4186   fail:
4187
4188     SWIG_croak_null();
4189   }
4190 }
4191
4192
4193 XS(_wrap_rait_device_open_from_children) {
4194   {
4195     GSList *arg1 = (GSList *) 0 ;
4196     int argvi = 0;
4197     Device *result = 0 ;
4198     dXSARGS;
4199
4200     if ((items < 1) || (items > 1)) {
4201       SWIG_croak("Usage: rait_device_open_from_children(child_devices);");
4202     }
4203     {
4204       AV *av;
4205       int i, len;
4206
4207       if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
4208         SWIG_exception(SWIG_TypeError, "Expected an arrayref");
4209       }
4210       av = (AV *)SvRV(ST(0));
4211
4212       arg1 = NULL;
4213       len = av_len(av);
4214       for (i = 0; i <= len; i++) {
4215         SV **elt = av_fetch(av, i, 0);
4216         Device *d;
4217
4218         if (elt && !SvOK(*elt)) {
4219           arg1 = g_slist_append(arg1, NULL); /* 'undef' => NULL */
4220         } else if (!elt || SWIG_ConvertPtr(*elt, (void **)&d, SWIGTYPE_p_Device, 0) == -1) {
4221           SWIG_exception(SWIG_TypeError, "array member is not a Device");
4222         } else {
4223           arg1 = g_slist_append(arg1, d);
4224         }
4225       }
4226     }
4227     result = (Device *)rait_device_open_from_children(arg1);
4228     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Device, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
4229     {
4230       g_slist_free(arg1);
4231     }
4232     XSRETURN(argvi);
4233   fail:
4234     {
4235       g_slist_free(arg1);
4236     }
4237     SWIG_croak_null();
4238   }
4239 }
4240
4241
4242 XS(_wrap_IS_WRITABLE_ACCESS_MODE) {
4243   {
4244     DeviceAccessMode arg1 ;
4245     int argvi = 0;
4246     gboolean result;
4247     dXSARGS;
4248
4249     if ((items < 1) || (items > 1)) {
4250       SWIG_croak("Usage: IS_WRITABLE_ACCESS_MODE(mode);");
4251     }
4252     {
4253       if (sizeof(signed int) == 1) {
4254         arg1 = amglue_SvI8(ST(0));
4255       } else if (sizeof(signed int) == 2) {
4256         arg1 = amglue_SvI16(ST(0));
4257       } else if (sizeof(signed int) == 4) {
4258         arg1 = amglue_SvI32(ST(0));
4259       } else if (sizeof(signed int) == 8) {
4260         arg1 = amglue_SvI64(ST(0));
4261       } else {
4262         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4263       }
4264     }
4265     result = (gboolean)IS_WRITABLE_ACCESS_MODE(arg1);
4266     {
4267       if (result)
4268       ST(argvi) = &PL_sv_yes;
4269       else
4270       ST(argvi) = &PL_sv_no;
4271       argvi++;
4272     }
4273
4274     XSRETURN(argvi);
4275   fail:
4276
4277     SWIG_croak_null();
4278   }
4279 }
4280
4281
4282
4283 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4284
4285 static swig_type_info _swigt__p_Device = {"_p_Device", "struct Device *|Device *", 0, 0, (void*)"Amanda::Device::Device", 0};
4286 static swig_type_info _swigt__p_DevicePropertyBase = {"_p_DevicePropertyBase", "DevicePropertyBase *", 0, 0, (void*)0, 0};
4287 static swig_type_info _swigt__p_DirectTCPConnection = {"_p_DirectTCPConnection", "struct DirectTCPConnection *|DirectTCPConnection *", 0, 0, (void*)"Amanda::Device::DirectTCPConnection", 0};
4288 static swig_type_info _swigt__p_GSList = {"_p_GSList", "GSList *", 0, 0, (void*)0, 0};
4289 static swig_type_info _swigt__p_GValue = {"_p_GValue", "GValue *", 0, 0, (void*)0, 0};
4290 static swig_type_info _swigt__p_a_STRMAX__char = {"_p_a_STRMAX__char", "char (*)[STRMAX]|string_t *", 0, 0, (void*)0, 0};
4291 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
4292 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
4293 static swig_type_info _swigt__p_dumpfile_t = {"_p_dumpfile_t", "dumpfile_t *", 0, 0, (void*)"Amanda::Header::Header", 0};
4294 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
4295 static swig_type_info _swigt__p_guint = {"_p_guint", "guint *", 0, 0, (void*)0, 0};
4296 static swig_type_info _swigt__p_guint64 = {"_p_guint64", "guint64 *", 0, 0, (void*)0, 0};
4297 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};
4298 static swig_type_info _swigt__p_p_DirectTCPAddr = {"_p_p_DirectTCPAddr", "DirectTCPAddr **", 0, 0, (void*)0, 0};
4299 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};
4300 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
4301
4302 static swig_type_info *swig_type_initial[] = {
4303   &_swigt__p_Device,
4304   &_swigt__p_DevicePropertyBase,
4305   &_swigt__p_DirectTCPConnection,
4306   &_swigt__p_GSList,
4307   &_swigt__p_GValue,
4308   &_swigt__p_a_STRMAX__char,
4309   &_swigt__p_char,
4310   &_swigt__p_double,
4311   &_swigt__p_dumpfile_t,
4312   &_swigt__p_float,
4313   &_swigt__p_guint,
4314   &_swigt__p_guint64,
4315   &_swigt__p_int,
4316   &_swigt__p_p_DirectTCPAddr,
4317   &_swigt__p_queue_fd_t,
4318   &_swigt__p_unsigned_char,
4319 };
4320
4321 static swig_cast_info _swigc__p_Device[] = {  {&_swigt__p_Device, 0, 0, 0},{0, 0, 0, 0}};
4322 static swig_cast_info _swigc__p_DevicePropertyBase[] = {  {&_swigt__p_DevicePropertyBase, 0, 0, 0},{0, 0, 0, 0}};
4323 static swig_cast_info _swigc__p_DirectTCPConnection[] = {  {&_swigt__p_DirectTCPConnection, 0, 0, 0},{0, 0, 0, 0}};
4324 static swig_cast_info _swigc__p_GSList[] = {  {&_swigt__p_GSList, 0, 0, 0},{0, 0, 0, 0}};
4325 static swig_cast_info _swigc__p_GValue[] = {  {&_swigt__p_GValue, 0, 0, 0},{0, 0, 0, 0}};
4326 static swig_cast_info _swigc__p_a_STRMAX__char[] = {  {&_swigt__p_a_STRMAX__char, 0, 0, 0},{0, 0, 0, 0}};
4327 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
4328 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
4329 static swig_cast_info _swigc__p_dumpfile_t[] = {  {&_swigt__p_dumpfile_t, 0, 0, 0},{0, 0, 0, 0}};
4330 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
4331 static swig_cast_info _swigc__p_guint[] = {  {&_swigt__p_guint, 0, 0, 0},{0, 0, 0, 0}};
4332 static swig_cast_info _swigc__p_guint64[] = {  {&_swigt__p_guint64, 0, 0, 0},{0, 0, 0, 0}};
4333 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
4334 static swig_cast_info _swigc__p_p_DirectTCPAddr[] = {  {&_swigt__p_p_DirectTCPAddr, 0, 0, 0},{0, 0, 0, 0}};
4335 static swig_cast_info _swigc__p_queue_fd_t[] = {  {&_swigt__p_queue_fd_t, 0, 0, 0},{0, 0, 0, 0}};
4336 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
4337
4338 static swig_cast_info *swig_cast_initial[] = {
4339   _swigc__p_Device,
4340   _swigc__p_DevicePropertyBase,
4341   _swigc__p_DirectTCPConnection,
4342   _swigc__p_GSList,
4343   _swigc__p_GValue,
4344   _swigc__p_a_STRMAX__char,
4345   _swigc__p_char,
4346   _swigc__p_double,
4347   _swigc__p_dumpfile_t,
4348   _swigc__p_float,
4349   _swigc__p_guint,
4350   _swigc__p_guint64,
4351   _swigc__p_int,
4352   _swigc__p_p_DirectTCPAddr,
4353   _swigc__p_queue_fd_t,
4354   _swigc__p_unsigned_char,
4355 };
4356
4357
4358 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4359
4360 static swig_constant_info swig_constants[] = {
4361 {0,0,0,0,0,0}
4362 };
4363 #ifdef __cplusplus
4364 }
4365 #endif
4366 static swig_variable_info swig_variables[] = {
4367 {0,0,0,0}
4368 };
4369 static swig_command_info swig_commands[] = {
4370 {"Amanda::Devicec::delete_DirectTCPConnection", _wrap_delete_DirectTCPConnection},
4371 {"Amanda::Devicec::DirectTCPConnection_close", _wrap_DirectTCPConnection_close},
4372 {"Amanda::Devicec::new_DirectTCPConnection", _wrap_new_DirectTCPConnection},
4373 {"Amanda::Devicec::queue_fd_t_fd_get", _wrap_queue_fd_t_fd_get},
4374 {"Amanda::Devicec::queue_fd_t_errmsg_get", _wrap_queue_fd_t_errmsg_get},
4375 {"Amanda::Devicec::new_queue_fd_t", _wrap_new_queue_fd_t},
4376 {"Amanda::Devicec::delete_queue_fd_t", _wrap_delete_queue_fd_t},
4377 {"Amanda::Devicec::unaliased_name", _wrap_unaliased_name},
4378 {"Amanda::Devicec::new_Device", _wrap_new_Device},
4379 {"Amanda::Devicec::delete_Device", _wrap_delete_Device},
4380 {"Amanda::Devicec::Device_configure", _wrap_Device_configure},
4381 {"Amanda::Devicec::Device_error", _wrap_Device_error},
4382 {"Amanda::Devicec::Device_status_error", _wrap_Device_status_error},
4383 {"Amanda::Devicec::Device_error_or_status", _wrap_Device_error_or_status},
4384 {"Amanda::Devicec::Device_read_label", _wrap_Device_read_label},
4385 {"Amanda::Devicec::Device_start", _wrap_Device_start},
4386 {"Amanda::Devicec::Device_finish", _wrap_Device_finish},
4387 {"Amanda::Devicec::Device_start_file", _wrap_Device_start_file},
4388 {"Amanda::Devicec::Device_write_block", _wrap_Device_write_block},
4389 {"Amanda::Devicec::Device_write_from_fd", _wrap_Device_write_from_fd},
4390 {"Amanda::Devicec::Device_finish_file", _wrap_Device_finish_file},
4391 {"Amanda::Devicec::Device_seek_file", _wrap_Device_seek_file},
4392 {"Amanda::Devicec::Device_seek_block", _wrap_Device_seek_block},
4393 {"Amanda::Devicec::Device_read_block", _wrap_Device_read_block},
4394 {"Amanda::Devicec::Device_read_to_fd", _wrap_Device_read_to_fd},
4395 {"Amanda::Devicec::Device_erase", _wrap_Device_erase},
4396 {"Amanda::Devicec::Device_eject", _wrap_Device_eject},
4397 {"Amanda::Devicec::Device_directtcp_supported", _wrap_Device_directtcp_supported},
4398 {"Amanda::Devicec::Device_listen", _wrap_Device_listen},
4399 {"Amanda::Devicec::Device_accept", _wrap_Device_accept},
4400 {"Amanda::Devicec::Device_use_connection", _wrap_Device_use_connection},
4401 {"Amanda::Devicec::Device_write_from_connection", _wrap_Device_write_from_connection},
4402 {"Amanda::Devicec::Device_read_to_connection", _wrap_Device_read_to_connection},
4403 {"Amanda::Devicec::Device_property_list", _wrap_Device_property_list},
4404 {"Amanda::Devicec::Device_property_get", _wrap_Device_property_get},
4405 {"Amanda::Devicec::Device_property_set", _wrap_Device_property_set},
4406 {"Amanda::Devicec::Device_property_set_ex", _wrap_Device_property_set_ex},
4407 {"Amanda::Devicec::Device_recycle_file", _wrap_Device_recycle_file},
4408 {"Amanda::Devicec::Device_file", _wrap_Device_file},
4409 {"Amanda::Devicec::Device_block", _wrap_Device_block},
4410 {"Amanda::Devicec::Device_in_file", _wrap_Device_in_file},
4411 {"Amanda::Devicec::Device_device_name", _wrap_Device_device_name},
4412 {"Amanda::Devicec::Device_access_mode", _wrap_Device_access_mode},
4413 {"Amanda::Devicec::Device_is_eof", _wrap_Device_is_eof},
4414 {"Amanda::Devicec::Device_is_eom", _wrap_Device_is_eom},
4415 {"Amanda::Devicec::Device_volume_label", _wrap_Device_volume_label},
4416 {"Amanda::Devicec::Device_volume_time", _wrap_Device_volume_time},
4417 {"Amanda::Devicec::Device_status", _wrap_Device_status},
4418 {"Amanda::Devicec::Device_min_block_size", _wrap_Device_min_block_size},
4419 {"Amanda::Devicec::Device_max_block_size", _wrap_Device_max_block_size},
4420 {"Amanda::Devicec::Device_block_size", _wrap_Device_block_size},
4421 {"Amanda::Devicec::Device_volume_header", _wrap_Device_volume_header},
4422 {"Amanda::Devicec::rait_device_open_from_children", _wrap_rait_device_open_from_children},
4423 {"Amanda::Devicec::IS_WRITABLE_ACCESS_MODE", _wrap_IS_WRITABLE_ACCESS_MODE},
4424 {0,0}
4425 };
4426 /* -----------------------------------------------------------------------------
4427  * Type initialization:
4428  * This problem is tough by the requirement that no dynamic
4429  * memory is used. Also, since swig_type_info structures store pointers to
4430  * swig_cast_info structures and swig_cast_info structures store pointers back
4431  * to swig_type_info structures, we need some lookup code at initialization.
4432  * The idea is that swig generates all the structures that are needed.
4433  * The runtime then collects these partially filled structures.
4434  * The SWIG_InitializeModule function takes these initial arrays out of
4435  * swig_module, and does all the lookup, filling in the swig_module.types
4436  * array with the correct data and linking the correct swig_cast_info
4437  * structures together.
4438  *
4439  * The generated swig_type_info structures are assigned staticly to an initial
4440  * array. We just loop through that array, and handle each type individually.
4441  * First we lookup if this type has been already loaded, and if so, use the
4442  * loaded structure instead of the generated one. Then we have to fill in the
4443  * cast linked list. The cast data is initially stored in something like a
4444  * two-dimensional array. Each row corresponds to a type (there are the same
4445  * number of rows as there are in the swig_type_initial array). Each entry in
4446  * a column is one of the swig_cast_info structures for that type.
4447  * The cast_initial array is actually an array of arrays, because each row has
4448  * a variable number of columns. So to actually build the cast linked list,
4449  * we find the array of casts associated with the type, and loop through it
4450  * adding the casts to the list. The one last trick we need to do is making
4451  * sure the type pointer in the swig_cast_info struct is correct.
4452  *
4453  * First off, we lookup the cast->type name to see if it is already loaded.
4454  * There are three cases to handle:
4455  *  1) If the cast->type has already been loaded AND the type we are adding
4456  *     casting info to has not been loaded (it is in this module), THEN we
4457  *     replace the cast->type pointer with the type pointer that has already
4458  *     been loaded.
4459  *  2) If BOTH types (the one we are adding casting info to, and the
4460  *     cast->type) are loaded, THEN the cast info has already been loaded by
4461  *     the previous module so we just ignore it.
4462  *  3) Finally, if cast->type has not already been loaded, then we add that
4463  *     swig_cast_info to the linked list (because the cast->type) pointer will
4464  *     be correct.
4465  * ----------------------------------------------------------------------------- */
4466
4467 #ifdef __cplusplus
4468 extern "C" {
4469 #if 0
4470 } /* c-mode */
4471 #endif
4472 #endif
4473
4474 #if 0
4475 #define SWIGRUNTIME_DEBUG
4476 #endif
4477
4478
4479 SWIGRUNTIME void
4480 SWIG_InitializeModule(void *clientdata) {
4481   size_t i;
4482   swig_module_info *module_head, *iter;
4483   int found, init;
4484
4485   clientdata = clientdata;
4486
4487   /* check to see if the circular list has been setup, if not, set it up */
4488   if (swig_module.next==0) {
4489     /* Initialize the swig_module */
4490     swig_module.type_initial = swig_type_initial;
4491     swig_module.cast_initial = swig_cast_initial;
4492     swig_module.next = &swig_module;
4493     init = 1;
4494   } else {
4495     init = 0;
4496   }
4497
4498   /* Try and load any already created modules */
4499   module_head = SWIG_GetModule(clientdata);
4500   if (!module_head) {
4501     /* This is the first module loaded for this interpreter */
4502     /* so set the swig module into the interpreter */
4503     SWIG_SetModule(clientdata, &swig_module);
4504     module_head = &swig_module;
4505   } else {
4506     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4507     found=0;
4508     iter=module_head;
4509     do {
4510       if (iter==&swig_module) {
4511         found=1;
4512         break;
4513       }
4514       iter=iter->next;
4515     } while (iter!= module_head);
4516
4517     /* if the is found in the list, then all is done and we may leave */
4518     if (found) return;
4519     /* otherwise we must add out module into the list */
4520     swig_module.next = module_head->next;
4521     module_head->next = &swig_module;
4522   }
4523
4524   /* When multiple interpeters are used, a module could have already been initialized in
4525        a different interpreter, but not yet have a pointer in this interpreter.
4526        In this case, we do not want to continue adding types... everything should be
4527        set up already */
4528   if (init == 0) return;
4529
4530   /* Now work on filling in swig_module.types */
4531 #ifdef SWIGRUNTIME_DEBUG
4532   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
4533 #endif
4534   for (i = 0; i < swig_module.size; ++i) {
4535     swig_type_info *type = 0;
4536     swig_type_info *ret;
4537     swig_cast_info *cast;
4538
4539 #ifdef SWIGRUNTIME_DEBUG
4540     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4541 #endif
4542
4543     /* if there is another module already loaded */
4544     if (swig_module.next != &swig_module) {
4545       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4546     }
4547     if (type) {
4548       /* Overwrite clientdata field */
4549 #ifdef SWIGRUNTIME_DEBUG
4550       printf("SWIG_InitializeModule: found type %s\n", type->name);
4551 #endif
4552       if (swig_module.type_initial[i]->clientdata) {
4553         type->clientdata = swig_module.type_initial[i]->clientdata;
4554 #ifdef SWIGRUNTIME_DEBUG
4555         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
4556 #endif
4557       }
4558     } else {
4559       type = swig_module.type_initial[i];
4560     }
4561
4562     /* Insert casting types */
4563     cast = swig_module.cast_initial[i];
4564     while (cast->type) {
4565       /* Don't need to add information already in the list */
4566       ret = 0;
4567 #ifdef SWIGRUNTIME_DEBUG
4568       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4569 #endif
4570       if (swig_module.next != &swig_module) {
4571         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4572 #ifdef SWIGRUNTIME_DEBUG
4573         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4574 #endif
4575       }
4576       if (ret) {
4577         if (type == swig_module.type_initial[i]) {
4578 #ifdef SWIGRUNTIME_DEBUG
4579           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4580 #endif
4581           cast->type = ret;
4582           ret = 0;
4583         } else {
4584           /* Check for casting already in the list */
4585           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4586 #ifdef SWIGRUNTIME_DEBUG
4587           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4588 #endif
4589           if (!ocast) ret = 0;
4590         }
4591       }
4592
4593       if (!ret) {
4594 #ifdef SWIGRUNTIME_DEBUG
4595         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4596 #endif
4597         if (type->cast) {
4598           type->cast->prev = cast;
4599           cast->next = type->cast;
4600         }
4601         type->cast = cast;
4602       }
4603       cast++;
4604     }
4605     /* Set entry in modules->types array equal to the type */
4606     swig_module.types[i] = type;
4607   }
4608   swig_module.types[i] = 0;
4609
4610 #ifdef SWIGRUNTIME_DEBUG
4611   printf("**** SWIG_InitializeModule: Cast List ******\n");
4612   for (i = 0; i < swig_module.size; ++i) {
4613     int j = 0;
4614     swig_cast_info *cast = swig_module.cast_initial[i];
4615     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4616     while (cast->type) {
4617       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4618       cast++;
4619       ++j;
4620     }
4621     printf("---- Total casts: %d\n",j);
4622   }
4623   printf("**** SWIG_InitializeModule: Cast List ******\n");
4624 #endif
4625 }
4626
4627 /* This function will propagate the clientdata field of type to
4628 * any new swig_type_info structures that have been added into the list
4629 * of equivalent types.  It is like calling
4630 * SWIG_TypeClientData(type, clientdata) a second time.
4631 */
4632 SWIGRUNTIME void
4633 SWIG_PropagateClientData(void) {
4634   size_t i;
4635   swig_cast_info *equiv;
4636   static int init_run = 0;
4637
4638   if (init_run) return;
4639   init_run = 1;
4640
4641   for (i = 0; i < swig_module.size; i++) {
4642     if (swig_module.types[i]->clientdata) {
4643       equiv = swig_module.types[i]->cast;
4644       while (equiv) {
4645         if (!equiv->converter) {
4646           if (equiv->type && !equiv->type->clientdata)
4647           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4648         }
4649         equiv = equiv->next;
4650       }
4651     }
4652   }
4653 }
4654
4655 #ifdef __cplusplus
4656 #if 0
4657 {
4658   /* c-mode */
4659 #endif
4660 }
4661 #endif
4662
4663
4664
4665 #ifdef __cplusplus
4666 extern "C"
4667 #endif
4668
4669 XS(SWIG_init) {
4670   dXSARGS;
4671   int i;
4672
4673   SWIG_InitializeModule(0);
4674
4675   /* Install commands */
4676   for (i = 0; swig_commands[i].name; i++) {
4677     newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
4678   }
4679
4680   /* Install variables */
4681   for (i = 0; swig_variables[i].name; i++) {
4682     SV *sv;
4683     sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
4684     if (swig_variables[i].type) {
4685       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
4686     } else {
4687       sv_setiv(sv,(IV) 0);
4688     }
4689     swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
4690   }
4691
4692   /* Install constant */
4693   for (i = 0; swig_constants[i].type; i++) {
4694     SV *sv;
4695     sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
4696     switch(swig_constants[i].type) {
4697     case SWIG_INT:
4698       sv_setiv(sv, (IV) swig_constants[i].lvalue);
4699       break;
4700     case SWIG_FLOAT:
4701       sv_setnv(sv, (double) swig_constants[i].dvalue);
4702       break;
4703     case SWIG_STRING:
4704       sv_setpv(sv, (char *) swig_constants[i].pvalue);
4705       break;
4706     case SWIG_POINTER:
4707       SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
4708       break;
4709     case SWIG_BINARY:
4710       SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
4711       break;
4712     default:
4713       break;
4714     }
4715     SvREADONLY_on(sv);
4716   }
4717
4718
4719   /* Initialize the Device API on load */
4720   device_api_init();
4721
4722   SWIG_TypeClientData(SWIGTYPE_p_DirectTCPConnection, (void*) "Amanda::Device::DirectTCPConnection");
4723   SWIG_TypeClientData(SWIGTYPE_p_queue_fd_t, (void*) "Amanda::Device::queue_fd_t");
4724   SWIG_TypeClientData(SWIGTYPE_p_Device, (void*) "Amanda::Device::Device");
4725   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4726     SV *sv = get_sv((char*) SWIG_prefix "ACCESS_NULL", TRUE | 0x2 | GV_ADDMULTI);
4727     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_NULL)));
4728     SvREADONLY_on(sv);
4729   } while(0) /*@SWIG@*/;
4730   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4731     SV *sv = get_sv((char*) SWIG_prefix "ACCESS_READ", TRUE | 0x2 | GV_ADDMULTI);
4732     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_READ)));
4733     SvREADONLY_on(sv);
4734   } while(0) /*@SWIG@*/;
4735   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4736     SV *sv = get_sv((char*) SWIG_prefix "ACCESS_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4737     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_WRITE)));
4738     SvREADONLY_on(sv);
4739   } while(0) /*@SWIG@*/;
4740   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4741     SV *sv = get_sv((char*) SWIG_prefix "ACCESS_APPEND", TRUE | 0x2 | GV_ADDMULTI);
4742     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_APPEND)));
4743     SvREADONLY_on(sv);
4744   } while(0) /*@SWIG@*/;
4745   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4746     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
4747     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_SUCCESS)));
4748     SvREADONLY_on(sv);
4749   } while(0) /*@SWIG@*/;
4750   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4751     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_DEVICE_ERROR", TRUE | 0x2 | GV_ADDMULTI);
4752     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_DEVICE_ERROR)));
4753     SvREADONLY_on(sv);
4754   } while(0) /*@SWIG@*/;
4755   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4756     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_DEVICE_BUSY", TRUE | 0x2 | GV_ADDMULTI);
4757     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_DEVICE_BUSY)));
4758     SvREADONLY_on(sv);
4759   } while(0) /*@SWIG@*/;
4760   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4761     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_MISSING", TRUE | 0x2 | GV_ADDMULTI);
4762     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_MISSING)));
4763     SvREADONLY_on(sv);
4764   } while(0) /*@SWIG@*/;
4765   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4766     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_UNLABELED", TRUE | 0x2 | GV_ADDMULTI);
4767     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_UNLABELED)));
4768     SvREADONLY_on(sv);
4769   } while(0) /*@SWIG@*/;
4770   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4771     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_ERROR", TRUE | 0x2 | GV_ADDMULTI);
4772     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_ERROR)));
4773     SvREADONLY_on(sv);
4774   } while(0) /*@SWIG@*/;
4775   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4776     SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_FLAGS_MAX", TRUE | 0x2 | GV_ADDMULTI);
4777     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_FLAGS_MAX)));
4778     SvREADONLY_on(sv);
4779   } while(0) /*@SWIG@*/;
4780   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4781     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
4782     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BEFORE_START)));
4783     SvREADONLY_on(sv);
4784   } while(0) /*@SWIG@*/;
4785   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4786     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4787     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BETWEEN_FILE_WRITE)));
4788     SvREADONLY_on(sv);
4789   } while(0) /*@SWIG@*/;
4790   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4791     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4792     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_INSIDE_FILE_WRITE)));
4793     SvREADONLY_on(sv);
4794   } while(0) /*@SWIG@*/;
4795   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4796     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4797     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BETWEEN_FILE_READ)));
4798     SvREADONLY_on(sv);
4799   } while(0) /*@SWIG@*/;
4800   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4801     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4802     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_INSIDE_FILE_READ)));
4803     SvREADONLY_on(sv);
4804   } while(0) /*@SWIG@*/;
4805   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4806     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_MAX", TRUE | 0x2 | GV_ADDMULTI);
4807     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_MAX)));
4808     SvREADONLY_on(sv);
4809   } while(0) /*@SWIG@*/;
4810   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4811     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_MASK", TRUE | 0x2 | GV_ADDMULTI);
4812     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_MASK)));
4813     SvREADONLY_on(sv);
4814   } while(0) /*@SWIG@*/;
4815   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4816     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_SHIFT", TRUE | 0x2 | GV_ADDMULTI);
4817     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_SHIFT)));
4818     SvREADONLY_on(sv);
4819   } while(0) /*@SWIG@*/;
4820   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4821     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
4822     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BEFORE_START)));
4823     SvREADONLY_on(sv);
4824   } while(0) /*@SWIG@*/;
4825   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4826     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4827     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE)));
4828     SvREADONLY_on(sv);
4829   } while(0) /*@SWIG@*/;
4830   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4831     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4832     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE)));
4833     SvREADONLY_on(sv);
4834   } while(0) /*@SWIG@*/;
4835   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4836     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4837     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BETWEEN_FILE_READ)));
4838     SvREADONLY_on(sv);
4839   } while(0) /*@SWIG@*/;
4840   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4841     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4842     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_INSIDE_FILE_READ)));
4843     SvREADONLY_on(sv);
4844   } while(0) /*@SWIG@*/;
4845   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4846     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
4847     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BEFORE_START)));
4848     SvREADONLY_on(sv);
4849   } while(0) /*@SWIG@*/;
4850   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4851     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4852     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE)));
4853     SvREADONLY_on(sv);
4854   } while(0) /*@SWIG@*/;
4855   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4856     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4857     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE)));
4858     SvREADONLY_on(sv);
4859   } while(0) /*@SWIG@*/;
4860   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4861     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4862     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BETWEEN_FILE_READ)));
4863     SvREADONLY_on(sv);
4864   } while(0) /*@SWIG@*/;
4865   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4866     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4867     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_INSIDE_FILE_READ)));
4868     SvREADONLY_on(sv);
4869   } while(0) /*@SWIG@*/;
4870   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4871     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_MASK", TRUE | 0x2 | GV_ADDMULTI);
4872     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_MASK)));
4873     SvREADONLY_on(sv);
4874   } while(0) /*@SWIG@*/;
4875   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4876     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_MASK", TRUE | 0x2 | GV_ADDMULTI);
4877     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_MASK)));
4878     SvREADONLY_on(sv);
4879   } while(0) /*@SWIG@*/;
4880   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4881     SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_EXCLUSIVE", TRUE | 0x2 | GV_ADDMULTI);
4882     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_EXCLUSIVE)));
4883     SvREADONLY_on(sv);
4884   } while(0) /*@SWIG@*/;
4885   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4886     SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_SHARED_READ", TRUE | 0x2 | GV_ADDMULTI);
4887     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_SHARED_READ)));
4888     SvREADONLY_on(sv);
4889   } while(0) /*@SWIG@*/;
4890   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4891     SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_RANDOM_ACCESS", TRUE | 0x2 | GV_ADDMULTI);
4892     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_RANDOM_ACCESS)));
4893     SvREADONLY_on(sv);
4894   } while(0) /*@SWIG@*/;
4895   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4896     SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_NONE", TRUE | 0x2 | GV_ADDMULTI);
4897     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_NONE)));
4898     SvREADONLY_on(sv);
4899   } while(0) /*@SWIG@*/;
4900   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4901     SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_DESIRED", TRUE | 0x2 | GV_ADDMULTI);
4902     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_DESIRED)));
4903     SvREADONLY_on(sv);
4904   } while(0) /*@SWIG@*/;
4905   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4906     SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_REQUIRED", TRUE | 0x2 | GV_ADDMULTI);
4907     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_REQUIRED)));
4908     SvREADONLY_on(sv);
4909   } while(0) /*@SWIG@*/;
4910   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4911     SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_READ_ONLY", TRUE | 0x2 | GV_ADDMULTI);
4912     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_READ_ONLY)));
4913     SvREADONLY_on(sv);
4914   } while(0) /*@SWIG@*/;
4915   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4916     SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_WORM", TRUE | 0x2 | GV_ADDMULTI);
4917     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_WORM)));
4918     SvREADONLY_on(sv);
4919   } while(0) /*@SWIG@*/;
4920   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4921     SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_READ_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4922     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_READ_WRITE)));
4923     SvREADONLY_on(sv);
4924   } while(0) /*@SWIG@*/;
4925   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4926     SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_WRITE_ONLY", TRUE | 0x2 | GV_ADDMULTI);
4927     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_WRITE_ONLY)));
4928     SvREADONLY_on(sv);
4929   } while(0) /*@SWIG@*/;
4930   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4931     SV *sv = get_sv((char*) SWIG_prefix "SIZE_ACCURACY_UNKNOWN", TRUE | 0x2 | GV_ADDMULTI);
4932     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SIZE_ACCURACY_UNKNOWN)));
4933     SvREADONLY_on(sv);
4934   } while(0) /*@SWIG@*/;
4935   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4936     SV *sv = get_sv((char*) SWIG_prefix "SIZE_ACCURACY_ESTIMATE", TRUE | 0x2 | GV_ADDMULTI);
4937     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SIZE_ACCURACY_ESTIMATE)));
4938     SvREADONLY_on(sv);
4939   } while(0) /*@SWIG@*/;
4940   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4941     SV *sv = get_sv((char*) SWIG_prefix "SIZE_ACCURACY_REAL", TRUE | 0x2 | GV_ADDMULTI);
4942     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SIZE_ACCURACY_REAL)));
4943     SvREADONLY_on(sv);
4944   } while(0) /*@SWIG@*/;
4945   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4946     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SURETY_BAD", TRUE | 0x2 | GV_ADDMULTI);
4947     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SURETY_BAD)));
4948     SvREADONLY_on(sv);
4949   } while(0) /*@SWIG@*/;
4950   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4951     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SURETY_GOOD", TRUE | 0x2 | GV_ADDMULTI);
4952     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SURETY_GOOD)));
4953     SvREADONLY_on(sv);
4954   } while(0) /*@SWIG@*/;
4955   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4956     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_DEFAULT", TRUE | 0x2 | GV_ADDMULTI);
4957     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_DEFAULT)));
4958     SvREADONLY_on(sv);
4959   } while(0) /*@SWIG@*/;
4960   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4961     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_DETECTED", TRUE | 0x2 | GV_ADDMULTI);
4962     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_DETECTED)));
4963     SvREADONLY_on(sv);
4964   } while(0) /*@SWIG@*/;
4965   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4966     SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_USER", TRUE | 0x2 | GV_ADDMULTI);
4967     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_USER)));
4968     SvREADONLY_on(sv);
4969   } while(0) /*@SWIG@*/;
4970   ST(0) = &PL_sv_yes;
4971   XSRETURN(1);
4972 }
4973