git.gag.com Git - debian/amanda/blob - perl/Amanda/NDMP.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_NDMPConnection swig_types[0]
1478 #define SWIGTYPE_p_char swig_types[1]
1479 #define SWIGTYPE_p_double swig_types[2]
1480 #define SWIGTYPE_p_float swig_types[3]
1481 #define SWIGTYPE_p_gint swig_types[4]
1482 #define SWIGTYPE_p_gsize swig_types[5]
1483 #define SWIGTYPE_p_guint swig_types[6]
1484 #define SWIGTYPE_p_guint32 swig_types[7]
1485 #define SWIGTYPE_p_guint64 swig_types[8]
1486 #define SWIGTYPE_p_guint8 swig_types[9]
1487 #define SWIGTYPE_p_int swig_types[10]
1488 #define SWIGTYPE_p_ndmp_enum swig_types[11]
1489 #define SWIGTYPE_p_unsigned_char swig_types[12]
1490 static swig_type_info *swig_types[14];
1491 static swig_module_info swig_module = {swig_types, 13, 0, 0, 0, 0};
1492 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1493 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1494
1495 /* -------- TYPES TABLE (END) -------- */
1496
1497 #define SWIG_init    boot_Amanda__NDMP
1498
1499 #define SWIG_name   "Amanda::NDMPc::boot_Amanda__NDMP"
1500 #define SWIG_prefix "Amanda::NDMPc::"
1501
1502 #define SWIGVERSION 0x010339
1503 #define SWIG_VERSION SWIGVERSION
1504
1505
1506 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1507 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1508
1509
1510 #ifdef __cplusplus
1511 extern "C"
1512 #endif
1513 #ifndef PERL_OBJECT
1514 #ifndef MULTIPLICITY
1515 SWIGEXPORT void SWIG_init (CV* cv);
1516 #else
1517 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1518 #endif
1519 #else
1520 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1521 #endif
1522
1523
1524 #include "amglue.h"
1525
1526
1527 #include "amglue.h"
1528
1529
1530 #include "amglue.h"
1531
1532
1533 #include "ndmpconnobj.h"
1534 #include "glib-util.h"
1535
1536
1537 typedef guint ndmp_enum;
1538
1539
1540 SWIGINTERN swig_type_info*
1541 SWIG_pchar_descriptor(void)
1542 {
1543   static int init = 0;
1544   static swig_type_info* info = 0;
1545   if (!init) {
1546     info = SWIG_TypeQuery("_p_char");
1547     init = 1;
1548   }
1549   return info;
1550 }
1551
1552
1553 SWIGINTERN int
1554 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1555 {
1556   if (SvMAGICAL(obj)) {
1557      SV *tmp = sv_newmortal();
1558      SvSetSV(tmp, obj);
1559      obj = tmp;
1560   }
1561   if (SvPOK(obj)) {
1562     STRLEN len = 0;
1563     char *cstr = SvPV(obj, len);
1564     size_t size = len + 1;
1565     if (cptr)  {
1566       if (alloc) {
1567         if (*alloc == SWIG_NEWOBJ) {
1568           *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1569         } else {
1570           *cptr = cstr;
1571           *alloc = SWIG_OLDOBJ;
1572         }
1573       }
1574     }
1575     if (psize) *psize = size;
1576     return SWIG_OK;
1577   } else {
1578     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1579     if (pchar_descriptor) {
1580       char* vptr = 0;
1581       if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1582         if (cptr) *cptr = vptr;
1583         if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1584         if (alloc) *alloc = SWIG_OLDOBJ;
1585         return SWIG_OK;
1586       }
1587     }
1588   }
1589   return SWIG_TypeError;
1590 }
1591
1592
1593
1594
1595 SWIGINTERN NDMPConnection *new_NDMPConnection(gchar *hostname,gint port,gchar *username,gchar *password,gchar *auth){
1596             return ndmp_connection_new(
1597                     hostname, port, username, password, auth);
1598         }
1599 SWIGINTERN void delete_NDMPConnection(NDMPConnection *self){
1600             g_object_unref(self);
1601         }
1602 SWIGINTERN int NDMPConnection_err_code(NDMPConnection *self){
1603             return ndmp_connection_err_code(self);
1604         }
1605 SWIGINTERN gchar *NDMPConnection_err_msg(NDMPConnection *self){
1606             return ndmp_connection_err_msg(self);
1607         }
1608
1609 SWIGINTERNINLINE SV *
1610 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1611 {
1612   SV *obj = sv_newmortal();
1613   if (carray) {
1614     sv_setpvn(obj, carray, size);
1615   } else {
1616     sv_setsv(obj, &PL_sv_undef);
1617   }
1618   return obj;
1619 }
1620
1621
1622 SWIGINTERNINLINE SV *
1623 SWIG_FromCharPtr(const char *cptr)
1624 {
1625   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1626 }
1627
1628
1629 #include <limits.h>
1630 #if !defined(SWIG_NO_LLONG_MAX)
1631 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1632 #   define LLONG_MAX __LONG_LONG_MAX__
1633 #   define LLONG_MIN (-LLONG_MAX - 1LL)
1634 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1635 # endif
1636 #endif
1637
1638
1639 SWIGINTERN int
1640 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1641 {
1642   if (SvNIOK(obj)) {
1643     if (val) *val = SvNV(obj);
1644     return SWIG_OK;
1645   } else if (SvIOK(obj)) {
1646     if (val) *val = (double) SvIV(obj);
1647     return SWIG_AddCast(SWIG_OK);
1648   } else {
1649     const char *nptr = SvPV_nolen(obj);
1650     if (nptr) {
1651       char *endptr;
1652       double v = strtod(nptr, &endptr);
1653       if (errno == ERANGE) {
1654         errno = 0;
1655         return SWIG_OverflowError;
1656       } else {
1657         if (*endptr == '\0') {
1658           if (val) *val = v;
1659           return SWIG_Str2NumCast(SWIG_OK);
1660         }
1661       }
1662     }
1663   }
1664   return SWIG_TypeError;
1665 }
1666
1667
1668 #include <float.h>
1669
1670
1671 #include <math.h>
1672
1673
1674 SWIGINTERNINLINE int
1675 SWIG_CanCastAsInteger(double *d, double min, double max) {
1676   double x = *d;
1677   if ((min <= x && x <= max)) {
1678    double fx = floor(x);
1679    double cx = ceil(x);
1680    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1681    if ((errno == EDOM) || (errno == ERANGE)) {
1682      errno = 0;
1683    } else {
1684      double summ, reps, diff;
1685      if (rd < x) {
1686        diff = x - rd;
1687      } else if (rd > x) {
1688        diff = rd - x;
1689      } else {
1690        return 1;
1691      }
1692      summ = rd + x;
1693      reps = diff/summ;
1694      if (reps < 8*DBL_EPSILON) {
1695        *d = rd;
1696        return 1;
1697      }
1698    }
1699   }
1700   return 0;
1701 }
1702
1703
1704 SWIGINTERN int
1705 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1706 {
1707   if (SvIOK(obj)) {
1708     if (val) *val = SvIV(obj);
1709     return SWIG_OK;
1710   } else {
1711     int dispatch = 0;
1712     const char *nptr = SvPV_nolen(obj);
1713     if (nptr) {
1714       char *endptr;
1715       long v;
1716       errno = 0;
1717       v = strtol(nptr, &endptr,0);
1718       if (errno == ERANGE) {
1719         errno = 0;
1720         return SWIG_OverflowError;
1721       } else {
1722         if (*endptr == '\0') {
1723           if (val) *val = v;
1724           return SWIG_Str2NumCast(SWIG_OK);
1725         }
1726       }
1727     }
1728     if (!dispatch) {
1729       double d;
1730       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1731       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1732         if (val) *val = (long)(d);
1733         return res;
1734       }
1735     }
1736   }
1737   return SWIG_TypeError;
1738 }
1739
1740
1741 SWIGINTERN int
1742 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1743 {
1744   long v;
1745   int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1746   if (SWIG_IsOK(res)) {
1747     if ((v < INT_MIN || v > INT_MAX)) {
1748       return SWIG_OverflowError;
1749     } else {
1750       if (val) *val = (int)(v);
1751     }
1752   }
1753   return res;
1754 }
1755
1756 SWIGINTERN void NDMPConnection_set_verbose(NDMPConnection *self,gboolean verbose){
1757             ndmp_connection_set_verbose(self, verbose);
1758         }
1759 SWIGINTERN gboolean NDMPConnection_scsi_open(NDMPConnection *self,gchar *device){
1760             return ndmp_connection_scsi_open(
1761                     self,
1762                     device);
1763         }
1764 SWIGINTERN gboolean NDMPConnection_scsi_close(NDMPConnection *self){
1765             return ndmp_connection_scsi_close(self);
1766         }
1767 SWIGINTERN gboolean NDMPConnection_scsi_execute_cdb_C(NDMPConnection *self,ndmp_enum flags,guint32 timeout,gpointer cdb,gsize cdb_len,gpointer dataout,gsize dataout_len,gsize *actual_dataout_len,gpointer datain,gsize datain_max_len,gsize *actual_datain_len,guint8 *status,gpointer ext_sense,gsize ext_sense_max_len,gsize *actual_ext_sense_len){
1768             return ndmp_connection_scsi_execute_cdb(
1769                     self,
1770                     flags,
1771                     timeout,
1772                     cdb,
1773                     cdb_len,
1774                     dataout,
1775                     dataout_len,
1776                     actual_dataout_len,
1777                     datain,
1778                     datain_max_len,
1779                     actual_datain_len,
1780                     status,
1781                     ext_sense,
1782                     ext_sense_max_len,
1783                     actual_ext_sense_len
1784                     );
1785         }
1786 SWIGINTERN gboolean NDMPConnection_tape_open(NDMPConnection *self,gchar *device,ndmp_enum mode){
1787             return ndmp_connection_tape_open(
1788                     self,
1789                     device,
1790                     mode);
1791         }
1792 SWIGINTERN gboolean NDMPConnection_tape_close(NDMPConnection *self){
1793             return ndmp_connection_tape_close(self);
1794         }
1795 SWIGINTERN gboolean NDMPConnection_tape_mtio(NDMPConnection *self,ndmp_enum tape_op,gint count,guint *resid){
1796             return ndmp_connection_tape_mtio(
1797                     self,
1798                     tape_op,
1799                     count,
1800                     resid);
1801         }
1802 SWIGINTERN gboolean NDMPConnection_tape_write(NDMPConnection *self,gpointer buf,guint64 len,guint64 *count){
1803             return ndmp_connection_tape_write(
1804                     self,
1805                     buf,
1806                     len,
1807                     count);
1808         }
1809 SWIGINTERN gboolean NDMPConnection_tape_read(NDMPConnection *self,gpointer buf,guint64 count,guint64 *out_count){
1810             return ndmp_connection_tape_read(
1811                     self,
1812                     buf,
1813                     count,
1814                     out_count);
1815         }
1816 SWIGINTERN gboolean NDMPConnection_tape_get_state(NDMPConnection *self,guint64 *blocksize,guint64 *file_num,guint64 *blockno){
1817             return ndmp_connection_tape_get_state(
1818                     self,
1819                     blocksize,
1820                     file_num,
1821                     blockno);
1822         }
1823
1824 SWIGINTERNINLINE SV *
1825 SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
1826 {
1827   SV *obj = sv_newmortal();
1828   sv_setiv(obj, (IV) value);
1829   return obj;
1830 }
1831
1832
1833 SWIGINTERNINLINE SV *
1834 SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
1835 {
1836   return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
1837 }
1838
1839 #ifdef __cplusplus
1840 extern "C" {
1841 #endif
1842
1843 #ifdef PERL_OBJECT
1844 #define MAGIC_CLASS _wrap_Amanda__NDMP_var::
1845 class _wrap_Amanda__NDMP_var : public CPerlObj {
1846 public:
1847 #else
1848 #define MAGIC_CLASS
1849 #endif
1850 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
1851     MAGIC_PPERL
1852     croak("Value is read-only.");
1853     return 0;
1854 }
1855
1856
1857 #ifdef PERL_OBJECT
1858 };
1859 #endif
1860
1861 #ifdef __cplusplus
1862 }
1863 #endif
1864
1865 #ifdef __cplusplus
1866 extern "C" {
1867 #endif
1868 XS(_wrap_new_NDMPConnection) {
1869   {
1870     gchar *arg1 = (gchar *) 0 ;
1871     gint arg2 ;
1872     gchar *arg3 = (gchar *) 0 ;
1873     gchar *arg4 = (gchar *) 0 ;
1874     gchar *arg5 = (gchar *) 0 ;
1875     int res1 ;
1876     char *buf1 = 0 ;
1877     int alloc1 = 0 ;
1878     int res3 ;
1879     char *buf3 = 0 ;
1880     int alloc3 = 0 ;
1881     int res4 ;
1882     char *buf4 = 0 ;
1883     int alloc4 = 0 ;
1884     int res5 ;
1885     char *buf5 = 0 ;
1886     int alloc5 = 0 ;
1887     int argvi = 0;
1888     NDMPConnection *result = 0 ;
1889     dXSARGS;
1890
1891     if ((items < 5) || (items > 5)) {
1892       SWIG_croak("Usage: new_NDMPConnection(hostname,port,username,password,auth);");
1893     }
1894     res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
1895     if (!SWIG_IsOK(res1)) {
1896       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NDMPConnection" "', argument " "1"" of type '" "gchar *""'");
1897     }
1898     arg1 = (gchar *)(buf1);
1899     {
1900       if (sizeof(gint) == 1) {
1901         arg2 = amglue_SvI8(ST(1));
1902       } else if (sizeof(gint) == 2) {
1903         arg2 = amglue_SvI16(ST(1));
1904       } else if (sizeof(gint) == 4) {
1905         arg2 = amglue_SvI32(ST(1));
1906       } else if (sizeof(gint) == 8) {
1907         arg2 = amglue_SvI64(ST(1));
1908       } else {
1909         g_critical("Unexpected gint >64 bits?"); /* should be optimized out unless sizeof(gint) > 8 */
1910       }
1911     }
1912     res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
1913     if (!SWIG_IsOK(res3)) {
1914       SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NDMPConnection" "', argument " "3"" of type '" "gchar *""'");
1915     }
1916     arg3 = (gchar *)(buf3);
1917     res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
1918     if (!SWIG_IsOK(res4)) {
1919       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_NDMPConnection" "', argument " "4"" of type '" "gchar *""'");
1920     }
1921     arg4 = (gchar *)(buf4);
1922     res5 = SWIG_AsCharPtrAndSize(ST(4), &buf5, NULL, &alloc5);
1923     if (!SWIG_IsOK(res5)) {
1924       SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_NDMPConnection" "', argument " "5"" of type '" "gchar *""'");
1925     }
1926     arg5 = (gchar *)(buf5);
1927     result = (NDMPConnection *)new_NDMPConnection(arg1,arg2,arg3,arg4,arg5);
1928     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_NDMPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
1929     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
1930     if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
1931     if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
1932     if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
1933     XSRETURN(argvi);
1934   fail:
1935     if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
1936     if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
1937     if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
1938     if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
1939     SWIG_croak_null();
1940   }
1941 }
1942
1943
1944 XS(_wrap_delete_NDMPConnection) {
1945   {
1946     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
1947     void *argp1 = 0 ;
1948     int res1 = 0 ;
1949     int argvi = 0;
1950     dXSARGS;
1951
1952     if ((items < 1) || (items > 1)) {
1953       SWIG_croak("Usage: delete_NDMPConnection(self);");
1954     }
1955     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, SWIG_POINTER_DISOWN |  0 );
1956     if (!SWIG_IsOK(res1)) {
1957       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NDMPConnection" "', argument " "1"" of type '" "NDMPConnection *""'");
1958     }
1959     arg1 = (NDMPConnection *)(argp1);
1960     delete_NDMPConnection(arg1);
1961     ST(argvi) = sv_newmortal();
1962
1963     XSRETURN(argvi);
1964   fail:
1965
1966     SWIG_croak_null();
1967   }
1968 }
1969
1970
1971 XS(_wrap_NDMPConnection_err_code) {
1972   {
1973     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
1974     void *argp1 = 0 ;
1975     int res1 = 0 ;
1976     int argvi = 0;
1977     int result;
1978     dXSARGS;
1979
1980     if ((items < 1) || (items > 1)) {
1981       SWIG_croak("Usage: NDMPConnection_err_code(self);");
1982     }
1983     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
1984     if (!SWIG_IsOK(res1)) {
1985       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_err_code" "', argument " "1"" of type '" "NDMPConnection *""'");
1986     }
1987     arg1 = (NDMPConnection *)(argp1);
1988     result = (int)NDMPConnection_err_code(arg1);
1989     {
1990       SV *for_stack;
1991       SP += argvi; PUTBACK;
1992       for_stack = sv_2mortal(amglue_newSVi64(result));
1993       SPAGAIN; SP -= argvi;
1994       ST(argvi) = for_stack;
1995       argvi++;
1996     }
1997
1998     XSRETURN(argvi);
1999   fail:
2000
2001     SWIG_croak_null();
2002   }
2003 }
2004
2005
2006 XS(_wrap_NDMPConnection_err_msg) {
2007   {
2008     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
2009     void *argp1 = 0 ;
2010     int res1 = 0 ;
2011     int argvi = 0;
2012     gchar *result = 0 ;
2013     dXSARGS;
2014
2015     if ((items < 1) || (items > 1)) {
2016       SWIG_croak("Usage: NDMPConnection_err_msg(self);");
2017     }
2018     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
2019     if (!SWIG_IsOK(res1)) {
2020       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_err_msg" "', argument " "1"" of type '" "NDMPConnection *""'");
2021     }
2022     arg1 = (NDMPConnection *)(argp1);
2023     result = (gchar *)NDMPConnection_err_msg(arg1);
2024     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2025
2026     free((char*)result);
2027     XSRETURN(argvi);
2028   fail:
2029
2030     SWIG_croak_null();
2031   }
2032 }
2033
2034
2035 XS(_wrap_NDMPConnection_set_verbose) {
2036   {
2037     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
2038     gboolean arg2 ;
2039     void *argp1 = 0 ;
2040     int res1 = 0 ;
2041     int argvi = 0;
2042     dXSARGS;
2043
2044     if ((items < 2) || (items > 2)) {
2045       SWIG_croak("Usage: NDMPConnection_set_verbose(self,verbose);");
2046     }
2047     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
2048     if (!SWIG_IsOK(res1)) {
2049       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_set_verbose" "', argument " "1"" of type '" "NDMPConnection *""'");
2050     }
2051     arg1 = (NDMPConnection *)(argp1);
2052     {
2053       if (sizeof(signed int) == 1) {
2054         arg2 = amglue_SvI8(ST(1));
2055       } else if (sizeof(signed int) == 2) {
2056         arg2 = amglue_SvI16(ST(1));
2057       } else if (sizeof(signed int) == 4) {
2058         arg2 = amglue_SvI32(ST(1));
2059       } else if (sizeof(signed int) == 8) {
2060         arg2 = amglue_SvI64(ST(1));
2061       } else {
2062         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2063       }
2064     }
2065     NDMPConnection_set_verbose(arg1,arg2);
2066     ST(argvi) = sv_newmortal();
2067
2068
2069     XSRETURN(argvi);
2070   fail:
2071
2072
2073     SWIG_croak_null();
2074   }
2075 }
2076
2077
2078 XS(_wrap_NDMPConnection_scsi_open) {
2079   {
2080     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
2081     gchar *arg2 = (gchar *) 0 ;
2082     void *argp1 = 0 ;
2083     int res1 = 0 ;
2084     int res2 ;
2085     char *buf2 = 0 ;
2086     int alloc2 = 0 ;
2087     int argvi = 0;
2088     gboolean result;
2089     dXSARGS;
2090
2091     if ((items < 2) || (items > 2)) {
2092       SWIG_croak("Usage: NDMPConnection_scsi_open(self,device);");
2093     }
2094     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
2095     if (!SWIG_IsOK(res1)) {
2096       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_scsi_open" "', argument " "1"" of type '" "NDMPConnection *""'");
2097     }
2098     arg1 = (NDMPConnection *)(argp1);
2099     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2100     if (!SWIG_IsOK(res2)) {
2101       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NDMPConnection_scsi_open" "', argument " "2"" of type '" "gchar *""'");
2102     }
2103     arg2 = (gchar *)(buf2);
2104     result = (gboolean)NDMPConnection_scsi_open(arg1,arg2);
2105     {
2106       if (result)
2107       ST(argvi) = &PL_sv_yes;
2108       else
2109       ST(argvi) = &PL_sv_no;
2110       argvi++;
2111     }
2112
2113     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2114     XSRETURN(argvi);
2115   fail:
2116
2117     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2118     SWIG_croak_null();
2119   }
2120 }
2121
2122
2123 XS(_wrap_NDMPConnection_scsi_close) {
2124   {
2125     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
2126     void *argp1 = 0 ;
2127     int res1 = 0 ;
2128     int argvi = 0;
2129     gboolean result;
2130     dXSARGS;
2131
2132     if ((items < 1) || (items > 1)) {
2133       SWIG_croak("Usage: NDMPConnection_scsi_close(self);");
2134     }
2135     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
2136     if (!SWIG_IsOK(res1)) {
2137       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_scsi_close" "', argument " "1"" of type '" "NDMPConnection *""'");
2138     }
2139     arg1 = (NDMPConnection *)(argp1);
2140     result = (gboolean)NDMPConnection_scsi_close(arg1);
2141     {
2142       if (result)
2143       ST(argvi) = &PL_sv_yes;
2144       else
2145       ST(argvi) = &PL_sv_no;
2146       argvi++;
2147     }
2148
2149     XSRETURN(argvi);
2150   fail:
2151
2152     SWIG_croak_null();
2153   }
2154 }
2155
2156
2157 XS(_wrap_NDMPConnection_scsi_execute_cdb_C) {
2158   {
2159     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
2160     ndmp_enum arg2 ;
2161     guint32 arg3 ;
2162     gpointer arg4 = (gpointer) 0 ;
2163     gsize arg5 ;
2164     gpointer arg6 = (gpointer) 0 ;
2165     gsize arg7 ;
2166     gsize *arg8 = (gsize *) 0 ;
2167     gpointer arg9 = (gpointer) 0 ;
2168     gsize arg10 ;
2169     gsize *arg11 = (gsize *) 0 ;
2170     guint8 *arg12 = (guint8 *) 0 ;
2171     gpointer arg13 = (gpointer) 0 ;
2172     gsize arg14 ;
2173     gsize *arg15 = (gsize *) 0 ;
2174     void *argp1 = 0 ;
2175     int res1 = 0 ;
2176     gsize dataout_len6 ;
2177     gpointer datain_buf9 ;
2178     gsize actual_datain_len9 ;
2179     guint8 temp12 ;
2180     guint8 ext_sense_buf13[128] ;
2181     gsize actual_ext_sense_len13 ;
2182     int argvi = 0;
2183     SV * _saved[2] ;
2184     gboolean result;
2185     dXSARGS;
2186
2187     arg12 = &temp12;
2188     {
2189       arg13 = ext_sense_buf13;
2190       arg14 = sizeof(ext_sense_buf13); /* always allocate 128 bytes for sense */
2191       actual_ext_sense_len13 = 0;
2192       arg15 = &actual_ext_sense_len13;
2193     }
2194     if ((items < 6) || (items > 6)) {
2195       SWIG_croak("Usage: NDMPConnection_scsi_execute_cdb_C(self,flags,timeout,cdb,cdb_len,dataout,dataout_len,actual_dataout_len,datain,datain_max_len,actual_datain_len,ext_sense_max_len,actual_ext_sense_len);");
2196     }
2197     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
2198     if (!SWIG_IsOK(res1)) {
2199       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_scsi_execute_cdb_C" "', argument " "1"" of type '" "NDMPConnection *""'");
2200     }
2201     arg1 = (NDMPConnection *)(argp1);
2202     arg2 = SvIV(ST(1));
2203     {
2204       arg3 = amglue_SvU32(ST(2));
2205     }
2206     {
2207       /* cdb */
2208       int alloc = SWIG_OLDOBJ;
2209       SWIG_AsCharPtrAndSize(ST(3), (char **)&arg4, &arg5, &alloc);
2210       if (arg5) arg5--; /* strip trailing NUL byte */
2211     }
2212     {
2213       /* dataout */
2214
2215       /* handle the actual input here */
2216       int alloc = SWIG_OLDOBJ;
2217       SWIG_AsCharPtrAndSize(ST(4), (char **)&arg6, &arg7, &alloc);
2218       if (arg7) arg7--; /* strip trailing NUL byte */
2219       /* set up for argout typemap, below */
2220       dataout_len6 = 0;
2221       arg8 = &dataout_len6;
2222     }
2223     {
2224       /* datain */
2225       gsize max_size = amglue_SvU64(ST(5));
2226       arg10 = max_size;
2227       if (max_size) {
2228         arg9 = g_malloc(max_size);
2229       } else {
2230         arg9 = NULL;
2231       }
2232       actual_datain_len9 = 0;
2233       arg11 = &actual_datain_len9;
2234     }
2235     _saved[0] = ST(4);
2236     _saved[1] = ST(5);
2237     result = (gboolean)NDMPConnection_scsi_execute_cdb_C(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
2238     {
2239       if (result)
2240       ST(argvi) = &PL_sv_yes;
2241       else
2242       ST(argvi) = &PL_sv_no;
2243       argvi++;
2244     }
2245     {
2246       if (argvi >= items) {
2247         EXTEND(sp,1);
2248       }
2249
2250       SP += argvi; PUTBACK;
2251       ST(argvi) = sv_2mortal(amglue_newSVu64(*arg8));
2252       SP -= argvi; argvi++;
2253     }
2254     {
2255       if (argvi >= items) {
2256         EXTEND(sp,1);
2257       }
2258
2259       /* convert the value, even if it's NULL */
2260       ST(argvi) = SWIG_FromCharPtrAndSize(arg9, *arg11);
2261       argvi++;
2262       if (arg9) g_free(arg9);
2263     }
2264     {
2265       if (argvi >= items) {
2266         EXTEND(sp,1);
2267       }
2268
2269       ST(argvi) = sv_newmortal();
2270       sv_setuv(ST(argvi), (UV)(*arg12));
2271       argvi++;
2272     }
2273     {
2274       if (argvi >= items) {
2275         EXTEND(sp,1);
2276       }
2277
2278       ST(argvi) = SWIG_FromCharPtrAndSize(arg13, *arg15);
2279       argvi++;
2280     }
2281
2282
2283     XSRETURN(argvi);
2284   fail:
2285
2286
2287     SWIG_croak_null();
2288   }
2289 }
2290
2291
2292 XS(_wrap_NDMPConnection_tape_open) {
2293   {
2294     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
2295     gchar *arg2 = (gchar *) 0 ;
2296     ndmp_enum arg3 ;
2297     void *argp1 = 0 ;
2298     int res1 = 0 ;
2299     int res2 ;
2300     char *buf2 = 0 ;
2301     int alloc2 = 0 ;
2302     int argvi = 0;
2303     gboolean result;
2304     dXSARGS;
2305
2306     if ((items < 3) || (items > 3)) {
2307       SWIG_croak("Usage: NDMPConnection_tape_open(self,device,mode);");
2308     }
2309     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
2310     if (!SWIG_IsOK(res1)) {
2311       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_tape_open" "', argument " "1"" of type '" "NDMPConnection *""'");
2312     }
2313     arg1 = (NDMPConnection *)(argp1);
2314     res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
2315     if (!SWIG_IsOK(res2)) {
2316       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NDMPConnection_tape_open" "', argument " "2"" of type '" "gchar *""'");
2317     }
2318     arg2 = (gchar *)(buf2);
2319     arg3 = SvIV(ST(2));
2320     result = (gboolean)NDMPConnection_tape_open(arg1,arg2,arg3);
2321     {
2322       if (result)
2323       ST(argvi) = &PL_sv_yes;
2324       else
2325       ST(argvi) = &PL_sv_no;
2326       argvi++;
2327     }
2328
2329     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2330     XSRETURN(argvi);
2331   fail:
2332
2333     if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2334     SWIG_croak_null();
2335   }
2336 }
2337
2338
2339 XS(_wrap_NDMPConnection_tape_close) {
2340   {
2341     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
2342     void *argp1 = 0 ;
2343     int res1 = 0 ;
2344     int argvi = 0;
2345     gboolean result;
2346     dXSARGS;
2347
2348     if ((items < 1) || (items > 1)) {
2349       SWIG_croak("Usage: NDMPConnection_tape_close(self);");
2350     }
2351     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
2352     if (!SWIG_IsOK(res1)) {
2353       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_tape_close" "', argument " "1"" of type '" "NDMPConnection *""'");
2354     }
2355     arg1 = (NDMPConnection *)(argp1);
2356     result = (gboolean)NDMPConnection_tape_close(arg1);
2357     {
2358       if (result)
2359       ST(argvi) = &PL_sv_yes;
2360       else
2361       ST(argvi) = &PL_sv_no;
2362       argvi++;
2363     }
2364
2365     XSRETURN(argvi);
2366   fail:
2367
2368     SWIG_croak_null();
2369   }
2370 }
2371
2372
2373 XS(_wrap_NDMPConnection_tape_mtio) {
2374   {
2375     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
2376     ndmp_enum arg2 ;
2377     gint arg3 ;
2378     guint *arg4 = (guint *) 0 ;
2379     void *argp1 = 0 ;
2380     int res1 = 0 ;
2381     guint temp4 ;
2382     int argvi = 0;
2383     gboolean result;
2384     dXSARGS;
2385
2386     arg4 = &temp4; temp4 = 0;
2387     if ((items < 3) || (items > 3)) {
2388       SWIG_croak("Usage: NDMPConnection_tape_mtio(self,tape_op,count);");
2389     }
2390     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
2391     if (!SWIG_IsOK(res1)) {
2392       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_tape_mtio" "', argument " "1"" of type '" "NDMPConnection *""'");
2393     }
2394     arg1 = (NDMPConnection *)(argp1);
2395     arg2 = SvIV(ST(1));
2396     {
2397       if (sizeof(gint) == 1) {
2398         arg3 = amglue_SvI8(ST(2));
2399       } else if (sizeof(gint) == 2) {
2400         arg3 = amglue_SvI16(ST(2));
2401       } else if (sizeof(gint) == 4) {
2402         arg3 = amglue_SvI32(ST(2));
2403       } else if (sizeof(gint) == 8) {
2404         arg3 = amglue_SvI64(ST(2));
2405       } else {
2406         g_critical("Unexpected gint >64 bits?"); /* should be optimized out unless sizeof(gint) > 8 */
2407       }
2408     }
2409     result = (gboolean)NDMPConnection_tape_mtio(arg1,arg2,arg3,arg4);
2410     {
2411       if (result)
2412       ST(argvi) = &PL_sv_yes;
2413       else
2414       ST(argvi) = &PL_sv_no;
2415       argvi++;
2416     }
2417     {
2418       if (argvi >= items) {
2419         EXTEND(sp,1);
2420       }
2421
2422       SP += argvi; PUTBACK;
2423       ST(argvi) = sv_2mortal(amglue_newSVu64(*arg4));
2424       SP -= argvi; argvi++;
2425     }
2426
2427
2428     XSRETURN(argvi);
2429   fail:
2430
2431
2432     SWIG_croak_null();
2433   }
2434 }
2435
2436
2437 XS(_wrap_NDMPConnection_tape_write) {
2438   {
2439     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
2440     gpointer arg2 = (gpointer) 0 ;
2441     guint64 arg3 ;
2442     guint64 *arg4 = (guint64 *) 0 ;
2443     void *argp1 = 0 ;
2444     int res1 = 0 ;
2445     guint64 temp4 ;
2446     int argvi = 0;
2447     gboolean result;
2448     dXSARGS;
2449
2450     arg4 = &temp4; temp4 = 0;
2451     if ((items < 2) || (items > 2)) {
2452       SWIG_croak("Usage: NDMPConnection_tape_write(self,buf,len);");
2453     }
2454     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
2455     if (!SWIG_IsOK(res1)) {
2456       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_tape_write" "', argument " "1"" of type '" "NDMPConnection *""'");
2457     }
2458     arg1 = (NDMPConnection *)(argp1);
2459     {
2460       int alloc = SWIG_OLDOBJ;
2461       size_t len_tmp; /* use a temporary with the right type */
2462       SWIG_AsCharPtrAndSize(ST(1), (char **)&arg2, &len_tmp, &alloc);
2463       if (len_tmp) len_tmp--; /* strip trailing NUL byte */
2464       arg3 = len_tmp;
2465     }
2466     result = (gboolean)NDMPConnection_tape_write(arg1,arg2,arg3,arg4);
2467     {
2468       if (result)
2469       ST(argvi) = &PL_sv_yes;
2470       else
2471       ST(argvi) = &PL_sv_no;
2472       argvi++;
2473     }
2474     {
2475       if (argvi >= items) {
2476         EXTEND(sp,1);
2477       }
2478
2479       SP += argvi; PUTBACK;
2480       ST(argvi) = sv_2mortal(amglue_newSVu64(*arg4));
2481       SP -= argvi; argvi++;
2482     }
2483
2484
2485     XSRETURN(argvi);
2486   fail:
2487
2488
2489     SWIG_croak_null();
2490   }
2491 }
2492
2493
2494 XS(_wrap_NDMPConnection_tape_read) {
2495   {
2496     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
2497     gpointer arg2 = (gpointer) 0 ;
2498     guint64 arg3 ;
2499     guint64 *arg4 = (guint64 *) 0 ;
2500     void *argp1 = 0 ;
2501     int res1 = 0 ;
2502     guint64 out_count2 ;
2503     int argvi = 0;
2504     SV * _saved[1] ;
2505     gboolean result;
2506     dXSARGS;
2507
2508     if ((items < 2) || (items > 2)) {
2509       SWIG_croak("Usage: NDMPConnection_tape_read(self,buf,count,out_count);");
2510     }
2511     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
2512     if (!SWIG_IsOK(res1)) {
2513       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_tape_read" "', argument " "1"" of type '" "NDMPConnection *""'");
2514     }
2515     arg1 = (NDMPConnection *)(argp1);
2516     {
2517       arg3 = amglue_SvU64(ST(1));
2518       arg2 = arg3?g_malloc(arg3):NULL;
2519       out_count2 = 0;
2520       arg4 = &out_count2;
2521     }
2522     _saved[0] = ST(1);
2523     result = (gboolean)NDMPConnection_tape_read(arg1,arg2,arg3,arg4);
2524     {
2525       if (result)
2526       ST(argvi) = &PL_sv_yes;
2527       else
2528       ST(argvi) = &PL_sv_no;
2529       argvi++;
2530     }
2531     {
2532       if (argvi >= items) {
2533         EXTEND(sp,1);
2534       }
2535
2536       /* convert the value, even if it's NULL */
2537       ST(argvi) = SWIG_FromCharPtrAndSize(arg2, *arg4);
2538       argvi++;
2539       if (arg2) g_free(arg2);
2540     }
2541
2542     XSRETURN(argvi);
2543   fail:
2544
2545     SWIG_croak_null();
2546   }
2547 }
2548
2549
2550 XS(_wrap_NDMPConnection_tape_get_state) {
2551   {
2552     NDMPConnection *arg1 = (NDMPConnection *) 0 ;
2553     guint64 *arg2 = (guint64 *) 0 ;
2554     guint64 *arg3 = (guint64 *) 0 ;
2555     guint64 *arg4 = (guint64 *) 0 ;
2556     void *argp1 = 0 ;
2557     int res1 = 0 ;
2558     guint64 temp2 ;
2559     guint64 temp3 ;
2560     guint64 temp4 ;
2561     int argvi = 0;
2562     gboolean result;
2563     dXSARGS;
2564
2565     arg2 = &temp2; temp2 = 0;
2566     arg3 = &temp3; temp3 = 0;
2567     arg4 = &temp4; temp4 = 0;
2568     if ((items < 1) || (items > 1)) {
2569       SWIG_croak("Usage: NDMPConnection_tape_get_state(self);");
2570     }
2571     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_NDMPConnection, 0 |  0 );
2572     if (!SWIG_IsOK(res1)) {
2573       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NDMPConnection_tape_get_state" "', argument " "1"" of type '" "NDMPConnection *""'");
2574     }
2575     arg1 = (NDMPConnection *)(argp1);
2576     result = (gboolean)NDMPConnection_tape_get_state(arg1,arg2,arg3,arg4);
2577     {
2578       if (result)
2579       ST(argvi) = &PL_sv_yes;
2580       else
2581       ST(argvi) = &PL_sv_no;
2582       argvi++;
2583     }
2584     {
2585       if (argvi >= items) {
2586         EXTEND(sp,1);
2587       }
2588
2589       SP += argvi; PUTBACK;
2590       ST(argvi) = sv_2mortal(amglue_newSVu64(*arg2));
2591       SP -= argvi; argvi++;
2592     }
2593     {
2594       if (argvi >= items) {
2595         EXTEND(sp,1);
2596       }
2597
2598       SP += argvi; PUTBACK;
2599       ST(argvi) = sv_2mortal(amglue_newSVu64(*arg3));
2600       SP -= argvi; argvi++;
2601     }
2602     {
2603       if (argvi >= items) {
2604         EXTEND(sp,1);
2605       }
2606
2607       SP += argvi; PUTBACK;
2608       ST(argvi) = sv_2mortal(amglue_newSVu64(*arg4));
2609       SP -= argvi; argvi++;
2610     }
2611
2612
2613
2614
2615     XSRETURN(argvi);
2616   fail:
2617
2618
2619
2620
2621     SWIG_croak_null();
2622   }
2623 }
2624
2625
2626
2627 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
2628
2629 static swig_type_info _swigt__p_NDMPConnection = {"_p_NDMPConnection", "struct NDMPConnection *|NDMPConnection *", 0, 0, (void*)"Amanda::NDMP::NDMPConnection", 0};
2630 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
2631 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
2632 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
2633 static swig_type_info _swigt__p_gint = {"_p_gint", "gint *", 0, 0, (void*)0, 0};
2634 static swig_type_info _swigt__p_gsize = {"_p_gsize", "gsize *", 0, 0, (void*)0, 0};
2635 static swig_type_info _swigt__p_guint = {"_p_guint", "guint *", 0, 0, (void*)0, 0};
2636 static swig_type_info _swigt__p_guint32 = {"_p_guint32", "guint32 *", 0, 0, (void*)0, 0};
2637 static swig_type_info _swigt__p_guint64 = {"_p_guint64", "guint64 *", 0, 0, (void*)0, 0};
2638 static swig_type_info _swigt__p_guint8 = {"_p_guint8", "guint8 *", 0, 0, (void*)0, 0};
2639 static swig_type_info _swigt__p_int = {"_p_int", "addr_type *|int *|tape_open_mode *|mover_mode *|data_halt_reason *|mover_halt_reason *|mover_pause_reason *|tape_mtio_op *|gboolean *|scsi_data_dir *|mover_state *", 0, 0, (void*)0, 0};
2640 static swig_type_info _swigt__p_ndmp_enum = {"_p_ndmp_enum", "ndmp_enum *", 0, 0, (void*)0, 0};
2641 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
2642
2643 static swig_type_info *swig_type_initial[] = {
2644   &_swigt__p_NDMPConnection,
2645   &_swigt__p_char,
2646   &_swigt__p_double,
2647   &_swigt__p_float,
2648   &_swigt__p_gint,
2649   &_swigt__p_gsize,
2650   &_swigt__p_guint,
2651   &_swigt__p_guint32,
2652   &_swigt__p_guint64,
2653   &_swigt__p_guint8,
2654   &_swigt__p_int,
2655   &_swigt__p_ndmp_enum,
2656   &_swigt__p_unsigned_char,
2657 };
2658
2659 static swig_cast_info _swigc__p_NDMPConnection[] = {  {&_swigt__p_NDMPConnection, 0, 0, 0},{0, 0, 0, 0}};
2660 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
2661 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
2662 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
2663 static swig_cast_info _swigc__p_gint[] = {  {&_swigt__p_gint, 0, 0, 0},{0, 0, 0, 0}};
2664 static swig_cast_info _swigc__p_gsize[] = {  {&_swigt__p_gsize, 0, 0, 0},{0, 0, 0, 0}};
2665 static swig_cast_info _swigc__p_guint[] = {  {&_swigt__p_guint, 0, 0, 0},{0, 0, 0, 0}};
2666 static swig_cast_info _swigc__p_guint32[] = {  {&_swigt__p_guint32, 0, 0, 0},{0, 0, 0, 0}};
2667 static swig_cast_info _swigc__p_guint64[] = {  {&_swigt__p_guint64, 0, 0, 0},{0, 0, 0, 0}};
2668 static swig_cast_info _swigc__p_guint8[] = {  {&_swigt__p_guint8, 0, 0, 0},{0, 0, 0, 0}};
2669 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
2670 static swig_cast_info _swigc__p_ndmp_enum[] = {  {&_swigt__p_ndmp_enum, 0, 0, 0},{0, 0, 0, 0}};
2671 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
2672
2673 static swig_cast_info *swig_cast_initial[] = {
2674   _swigc__p_NDMPConnection,
2675   _swigc__p_char,
2676   _swigc__p_double,
2677   _swigc__p_float,
2678   _swigc__p_gint,
2679   _swigc__p_gsize,
2680   _swigc__p_guint,
2681   _swigc__p_guint32,
2682   _swigc__p_guint64,
2683   _swigc__p_guint8,
2684   _swigc__p_int,
2685   _swigc__p_ndmp_enum,
2686   _swigc__p_unsigned_char,
2687 };
2688
2689
2690 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
2691
2692 static swig_constant_info swig_constants[] = {
2693 {0,0,0,0,0,0}
2694 };
2695 #ifdef __cplusplus
2696 }
2697 #endif
2698 static swig_variable_info swig_variables[] = {
2699 {0,0,0,0}
2700 };
2701 static swig_command_info swig_commands[] = {
2702 {"Amanda::NDMPc::new_NDMPConnection", _wrap_new_NDMPConnection},
2703 {"Amanda::NDMPc::delete_NDMPConnection", _wrap_delete_NDMPConnection},
2704 {"Amanda::NDMPc::NDMPConnection_err_code", _wrap_NDMPConnection_err_code},
2705 {"Amanda::NDMPc::NDMPConnection_err_msg", _wrap_NDMPConnection_err_msg},
2706 {"Amanda::NDMPc::NDMPConnection_set_verbose", _wrap_NDMPConnection_set_verbose},
2707 {"Amanda::NDMPc::NDMPConnection_scsi_open", _wrap_NDMPConnection_scsi_open},
2708 {"Amanda::NDMPc::NDMPConnection_scsi_close", _wrap_NDMPConnection_scsi_close},
2709 {"Amanda::NDMPc::NDMPConnection_scsi_execute_cdb_C", _wrap_NDMPConnection_scsi_execute_cdb_C},
2710 {"Amanda::NDMPc::NDMPConnection_tape_open", _wrap_NDMPConnection_tape_open},
2711 {"Amanda::NDMPc::NDMPConnection_tape_close", _wrap_NDMPConnection_tape_close},
2712 {"Amanda::NDMPc::NDMPConnection_tape_mtio", _wrap_NDMPConnection_tape_mtio},
2713 {"Amanda::NDMPc::NDMPConnection_tape_write", _wrap_NDMPConnection_tape_write},
2714 {"Amanda::NDMPc::NDMPConnection_tape_read", _wrap_NDMPConnection_tape_read},
2715 {"Amanda::NDMPc::NDMPConnection_tape_get_state", _wrap_NDMPConnection_tape_get_state},
2716 {0,0}
2717 };
2718 /* -----------------------------------------------------------------------------
2719  * Type initialization:
2720  * This problem is tough by the requirement that no dynamic
2721  * memory is used. Also, since swig_type_info structures store pointers to
2722  * swig_cast_info structures and swig_cast_info structures store pointers back
2723  * to swig_type_info structures, we need some lookup code at initialization.
2724  * The idea is that swig generates all the structures that are needed.
2725  * The runtime then collects these partially filled structures.
2726  * The SWIG_InitializeModule function takes these initial arrays out of
2727  * swig_module, and does all the lookup, filling in the swig_module.types
2728  * array with the correct data and linking the correct swig_cast_info
2729  * structures together.
2730  *
2731  * The generated swig_type_info structures are assigned staticly to an initial
2732  * array. We just loop through that array, and handle each type individually.
2733  * First we lookup if this type has been already loaded, and if so, use the
2734  * loaded structure instead of the generated one. Then we have to fill in the
2735  * cast linked list. The cast data is initially stored in something like a
2736  * two-dimensional array. Each row corresponds to a type (there are the same
2737  * number of rows as there are in the swig_type_initial array). Each entry in
2738  * a column is one of the swig_cast_info structures for that type.
2739  * The cast_initial array is actually an array of arrays, because each row has
2740  * a variable number of columns. So to actually build the cast linked list,
2741  * we find the array of casts associated with the type, and loop through it
2742  * adding the casts to the list. The one last trick we need to do is making
2743  * sure the type pointer in the swig_cast_info struct is correct.
2744  *
2745  * First off, we lookup the cast->type name to see if it is already loaded.
2746  * There are three cases to handle:
2747  *  1) If the cast->type has already been loaded AND the type we are adding
2748  *     casting info to has not been loaded (it is in this module), THEN we
2749  *     replace the cast->type pointer with the type pointer that has already
2750  *     been loaded.
2751  *  2) If BOTH types (the one we are adding casting info to, and the
2752  *     cast->type) are loaded, THEN the cast info has already been loaded by
2753  *     the previous module so we just ignore it.
2754  *  3) Finally, if cast->type has not already been loaded, then we add that
2755  *     swig_cast_info to the linked list (because the cast->type) pointer will
2756  *     be correct.
2757  * ----------------------------------------------------------------------------- */
2758
2759 #ifdef __cplusplus
2760 extern "C" {
2761 #if 0
2762 } /* c-mode */
2763 #endif
2764 #endif
2765
2766 #if 0
2767 #define SWIGRUNTIME_DEBUG
2768 #endif
2769
2770
2771 SWIGRUNTIME void
2772 SWIG_InitializeModule(void *clientdata) {
2773   size_t i;
2774   swig_module_info *module_head, *iter;
2775   int found, init;
2776
2777   clientdata = clientdata;
2778
2779   /* check to see if the circular list has been setup, if not, set it up */
2780   if (swig_module.next==0) {
2781     /* Initialize the swig_module */
2782     swig_module.type_initial = swig_type_initial;
2783     swig_module.cast_initial = swig_cast_initial;
2784     swig_module.next = &swig_module;
2785     init = 1;
2786   } else {
2787     init = 0;
2788   }
2789
2790   /* Try and load any already created modules */
2791   module_head = SWIG_GetModule(clientdata);
2792   if (!module_head) {
2793     /* This is the first module loaded for this interpreter */
2794     /* so set the swig module into the interpreter */
2795     SWIG_SetModule(clientdata, &swig_module);
2796     module_head = &swig_module;
2797   } else {
2798     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
2799     found=0;
2800     iter=module_head;
2801     do {
2802       if (iter==&swig_module) {
2803         found=1;
2804         break;
2805       }
2806       iter=iter->next;
2807     } while (iter!= module_head);
2808
2809     /* if the is found in the list, then all is done and we may leave */
2810     if (found) return;
2811     /* otherwise we must add out module into the list */
2812     swig_module.next = module_head->next;
2813     module_head->next = &swig_module;
2814   }
2815
2816   /* When multiple interpeters are used, a module could have already been initialized in
2817        a different interpreter, but not yet have a pointer in this interpreter.
2818        In this case, we do not want to continue adding types... everything should be
2819        set up already */
2820   if (init == 0) return;
2821
2822   /* Now work on filling in swig_module.types */
2823 #ifdef SWIGRUNTIME_DEBUG
2824   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
2825 #endif
2826   for (i = 0; i < swig_module.size; ++i) {
2827     swig_type_info *type = 0;
2828     swig_type_info *ret;
2829     swig_cast_info *cast;
2830
2831 #ifdef SWIGRUNTIME_DEBUG
2832     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
2833 #endif
2834
2835     /* if there is another module already loaded */
2836     if (swig_module.next != &swig_module) {
2837       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
2838     }
2839     if (type) {
2840       /* Overwrite clientdata field */
2841 #ifdef SWIGRUNTIME_DEBUG
2842       printf("SWIG_InitializeModule: found type %s\n", type->name);
2843 #endif
2844       if (swig_module.type_initial[i]->clientdata) {
2845         type->clientdata = swig_module.type_initial[i]->clientdata;
2846 #ifdef SWIGRUNTIME_DEBUG
2847         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
2848 #endif
2849       }
2850     } else {
2851       type = swig_module.type_initial[i];
2852     }
2853
2854     /* Insert casting types */
2855     cast = swig_module.cast_initial[i];
2856     while (cast->type) {
2857       /* Don't need to add information already in the list */
2858       ret = 0;
2859 #ifdef SWIGRUNTIME_DEBUG
2860       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
2861 #endif
2862       if (swig_module.next != &swig_module) {
2863         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
2864 #ifdef SWIGRUNTIME_DEBUG
2865         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
2866 #endif
2867       }
2868       if (ret) {
2869         if (type == swig_module.type_initial[i]) {
2870 #ifdef SWIGRUNTIME_DEBUG
2871           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
2872 #endif
2873           cast->type = ret;
2874           ret = 0;
2875         } else {
2876           /* Check for casting already in the list */
2877           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
2878 #ifdef SWIGRUNTIME_DEBUG
2879           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
2880 #endif
2881           if (!ocast) ret = 0;
2882         }
2883       }
2884
2885       if (!ret) {
2886 #ifdef SWIGRUNTIME_DEBUG
2887         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
2888 #endif
2889         if (type->cast) {
2890           type->cast->prev = cast;
2891           cast->next = type->cast;
2892         }
2893         type->cast = cast;
2894       }
2895       cast++;
2896     }
2897     /* Set entry in modules->types array equal to the type */
2898     swig_module.types[i] = type;
2899   }
2900   swig_module.types[i] = 0;
2901
2902 #ifdef SWIGRUNTIME_DEBUG
2903   printf("**** SWIG_InitializeModule: Cast List ******\n");
2904   for (i = 0; i < swig_module.size; ++i) {
2905     int j = 0;
2906     swig_cast_info *cast = swig_module.cast_initial[i];
2907     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
2908     while (cast->type) {
2909       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
2910       cast++;
2911       ++j;
2912     }
2913     printf("---- Total casts: %d\n",j);
2914   }
2915   printf("**** SWIG_InitializeModule: Cast List ******\n");
2916 #endif
2917 }
2918
2919 /* This function will propagate the clientdata field of type to
2920 * any new swig_type_info structures that have been added into the list
2921 * of equivalent types.  It is like calling
2922 * SWIG_TypeClientData(type, clientdata) a second time.
2923 */
2924 SWIGRUNTIME void
2925 SWIG_PropagateClientData(void) {
2926   size_t i;
2927   swig_cast_info *equiv;
2928   static int init_run = 0;
2929
2930   if (init_run) return;
2931   init_run = 1;
2932
2933   for (i = 0; i < swig_module.size; i++) {
2934     if (swig_module.types[i]->clientdata) {
2935       equiv = swig_module.types[i]->cast;
2936       while (equiv) {
2937         if (!equiv->converter) {
2938           if (equiv->type && !equiv->type->clientdata)
2939           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
2940         }
2941         equiv = equiv->next;
2942       }
2943     }
2944   }
2945 }
2946
2947 #ifdef __cplusplus
2948 #if 0
2949 {
2950   /* c-mode */
2951 #endif
2952 }
2953 #endif
2954
2955
2956
2957 #ifdef __cplusplus
2958 extern "C"
2959 #endif
2960
2961 XS(SWIG_init) {
2962   dXSARGS;
2963   int i;
2964
2965   SWIG_InitializeModule(0);
2966
2967   /* Install commands */
2968   for (i = 0; swig_commands[i].name; i++) {
2969     newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
2970   }
2971
2972   /* Install variables */
2973   for (i = 0; swig_variables[i].name; i++) {
2974     SV *sv;
2975     sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
2976     if (swig_variables[i].type) {
2977       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
2978     } else {
2979       sv_setiv(sv,(IV) 0);
2980     }
2981     swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
2982   }
2983
2984   /* Install constant */
2985   for (i = 0; swig_constants[i].type; i++) {
2986     SV *sv;
2987     sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
2988     switch(swig_constants[i].type) {
2989     case SWIG_INT:
2990       sv_setiv(sv, (IV) swig_constants[i].lvalue);
2991       break;
2992     case SWIG_FLOAT:
2993       sv_setnv(sv, (double) swig_constants[i].dvalue);
2994       break;
2995     case SWIG_STRING:
2996       sv_setpv(sv, (char *) swig_constants[i].pvalue);
2997       break;
2998     case SWIG_POINTER:
2999       SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
3000       break;
3001     case SWIG_BINARY:
3002       SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
3003       break;
3004     default:
3005       break;
3006     }
3007     SvREADONLY_on(sv);
3008   }
3009
3010
3011   glib_init();
3012
3013   SWIG_TypeClientData(SWIGTYPE_p_NDMPConnection, (void*) "Amanda::NDMP::NDMPConnection");
3014   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3015     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_SCSI_DATA_DIR_NONE", TRUE | 0x2 | GV_ADDMULTI);
3016     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_SCSI_DATA_DIR_NONE)));
3017     SvREADONLY_on(sv);
3018   } while(0) /*@SWIG@*/;
3019   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3020     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_SCSI_DATA_DIR_IN", TRUE | 0x2 | GV_ADDMULTI);
3021     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_SCSI_DATA_DIR_IN)));
3022     SvREADONLY_on(sv);
3023   } while(0) /*@SWIG@*/;
3024   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3025     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_SCSI_DATA_DIR_OUT", TRUE | 0x2 | GV_ADDMULTI);
3026     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_SCSI_DATA_DIR_OUT)));
3027     SvREADONLY_on(sv);
3028   } while(0) /*@SWIG@*/;
3029   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3030     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_TAPE_READ_MODE", TRUE | 0x2 | GV_ADDMULTI);
3031     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_TAPE_READ_MODE)));
3032     SvREADONLY_on(sv);
3033   } while(0) /*@SWIG@*/;
3034   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3035     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_TAPE_RDWR_MODE", TRUE | 0x2 | GV_ADDMULTI);
3036     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_TAPE_RDWR_MODE)));
3037     SvREADONLY_on(sv);
3038   } while(0) /*@SWIG@*/;
3039   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3040     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_TAPE_RAW_MODE", TRUE | 0x2 | GV_ADDMULTI);
3041     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_TAPE_RAW_MODE)));
3042     SvREADONLY_on(sv);
3043   } while(0) /*@SWIG@*/;
3044   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3045     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MTIO_FSF", TRUE | 0x2 | GV_ADDMULTI);
3046     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MTIO_FSF)));
3047     SvREADONLY_on(sv);
3048   } while(0) /*@SWIG@*/;
3049   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3050     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MTIO_BSF", TRUE | 0x2 | GV_ADDMULTI);
3051     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MTIO_BSF)));
3052     SvREADONLY_on(sv);
3053   } while(0) /*@SWIG@*/;
3054   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3055     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MTIO_FSR", TRUE | 0x2 | GV_ADDMULTI);
3056     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MTIO_FSR)));
3057     SvREADONLY_on(sv);
3058   } while(0) /*@SWIG@*/;
3059   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3060     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MTIO_BSR", TRUE | 0x2 | GV_ADDMULTI);
3061     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MTIO_BSR)));
3062     SvREADONLY_on(sv);
3063   } while(0) /*@SWIG@*/;
3064   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3065     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MTIO_REW", TRUE | 0x2 | GV_ADDMULTI);
3066     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MTIO_REW)));
3067     SvREADONLY_on(sv);
3068   } while(0) /*@SWIG@*/;
3069   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3070     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MTIO_EOF", TRUE | 0x2 | GV_ADDMULTI);
3071     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MTIO_EOF)));
3072     SvREADONLY_on(sv);
3073   } while(0) /*@SWIG@*/;
3074   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3075     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MTIO_OFF", TRUE | 0x2 | GV_ADDMULTI);
3076     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MTIO_OFF)));
3077     SvREADONLY_on(sv);
3078   } while(0) /*@SWIG@*/;
3079   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3080     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_MODE_READ", TRUE | 0x2 | GV_ADDMULTI);
3081     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_MODE_READ)));
3082     SvREADONLY_on(sv);
3083   } while(0) /*@SWIG@*/;
3084   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3085     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_MODE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
3086     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_MODE_WRITE)));
3087     SvREADONLY_on(sv);
3088   } while(0) /*@SWIG@*/;
3089   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3090     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_ADDR_LOCAL", TRUE | 0x2 | GV_ADDMULTI);
3091     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_ADDR_LOCAL)));
3092     SvREADONLY_on(sv);
3093   } while(0) /*@SWIG@*/;
3094   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3095     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_ADDR_TCP", TRUE | 0x2 | GV_ADDMULTI);
3096     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_ADDR_TCP)));
3097     SvREADONLY_on(sv);
3098   } while(0) /*@SWIG@*/;
3099   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3100     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_ADDR_AS_CONNECTED", TRUE | 0x2 | GV_ADDMULTI);
3101     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_ADDR_AS_CONNECTED)));
3102     SvREADONLY_on(sv);
3103   } while(0) /*@SWIG@*/;
3104   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3105     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_STATE_IDLE", TRUE | 0x2 | GV_ADDMULTI);
3106     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_STATE_IDLE)));
3107     SvREADONLY_on(sv);
3108   } while(0) /*@SWIG@*/;
3109   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3110     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_STATE_LISTEN", TRUE | 0x2 | GV_ADDMULTI);
3111     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_STATE_LISTEN)));
3112     SvREADONLY_on(sv);
3113   } while(0) /*@SWIG@*/;
3114   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3115     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_STATE_ACTIVE", TRUE | 0x2 | GV_ADDMULTI);
3116     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_STATE_ACTIVE)));
3117     SvREADONLY_on(sv);
3118   } while(0) /*@SWIG@*/;
3119   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3120     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_STATE_PAUSED", TRUE | 0x2 | GV_ADDMULTI);
3121     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_STATE_PAUSED)));
3122     SvREADONLY_on(sv);
3123   } while(0) /*@SWIG@*/;
3124   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3125     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_STATE_HALTED", TRUE | 0x2 | GV_ADDMULTI);
3126     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_STATE_HALTED)));
3127     SvREADONLY_on(sv);
3128   } while(0) /*@SWIG@*/;
3129   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3130     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_STATE_STANDBY", TRUE | 0x2 | GV_ADDMULTI);
3131     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_STATE_STANDBY)));
3132     SvREADONLY_on(sv);
3133   } while(0) /*@SWIG@*/;
3134   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3135     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_DATA_HALT_NA", TRUE | 0x2 | GV_ADDMULTI);
3136     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_DATA_HALT_NA)));
3137     SvREADONLY_on(sv);
3138   } while(0) /*@SWIG@*/;
3139   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3140     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_DATA_HALT_SUCCESSFUL", TRUE | 0x2 | GV_ADDMULTI);
3141     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_DATA_HALT_SUCCESSFUL)));
3142     SvREADONLY_on(sv);
3143   } while(0) /*@SWIG@*/;
3144   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3145     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_DATA_HALT_ABORTED", TRUE | 0x2 | GV_ADDMULTI);
3146     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_DATA_HALT_ABORTED)));
3147     SvREADONLY_on(sv);
3148   } while(0) /*@SWIG@*/;
3149   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3150     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_DATA_HALT_INTERNAL_ERROR", TRUE | 0x2 | GV_ADDMULTI);
3151     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_DATA_HALT_INTERNAL_ERROR)));
3152     SvREADONLY_on(sv);
3153   } while(0) /*@SWIG@*/;
3154   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3155     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_DATA_HALT_CONNECT_ERROR", TRUE | 0x2 | GV_ADDMULTI);
3156     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_DATA_HALT_CONNECT_ERROR)));
3157     SvREADONLY_on(sv);
3158   } while(0) /*@SWIG@*/;
3159   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3160     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_HALT_NA", TRUE | 0x2 | GV_ADDMULTI);
3161     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_HALT_NA)));
3162     SvREADONLY_on(sv);
3163   } while(0) /*@SWIG@*/;
3164   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3165     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_HALT_CONNECT_CLOSED", TRUE | 0x2 | GV_ADDMULTI);
3166     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_HALT_CONNECT_CLOSED)));
3167     SvREADONLY_on(sv);
3168   } while(0) /*@SWIG@*/;
3169   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3170     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_HALT_ABORTED", TRUE | 0x2 | GV_ADDMULTI);
3171     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_HALT_ABORTED)));
3172     SvREADONLY_on(sv);
3173   } while(0) /*@SWIG@*/;
3174   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3175     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_HALT_INTERNAL_ERROR", TRUE | 0x2 | GV_ADDMULTI);
3176     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_HALT_INTERNAL_ERROR)));
3177     SvREADONLY_on(sv);
3178   } while(0) /*@SWIG@*/;
3179   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3180     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_HALT_CONNECT_ERROR", TRUE | 0x2 | GV_ADDMULTI);
3181     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_HALT_CONNECT_ERROR)));
3182     SvREADONLY_on(sv);
3183   } while(0) /*@SWIG@*/;
3184   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3185     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_PAUSE_NA", TRUE | 0x2 | GV_ADDMULTI);
3186     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_PAUSE_NA)));
3187     SvREADONLY_on(sv);
3188   } while(0) /*@SWIG@*/;
3189   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3190     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_PAUSE_EOM", TRUE | 0x2 | GV_ADDMULTI);
3191     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_PAUSE_EOM)));
3192     SvREADONLY_on(sv);
3193   } while(0) /*@SWIG@*/;
3194   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3195     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_PAUSE_EOF", TRUE | 0x2 | GV_ADDMULTI);
3196     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_PAUSE_EOF)));
3197     SvREADONLY_on(sv);
3198   } while(0) /*@SWIG@*/;
3199   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3200     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_PAUSE_SEEK", TRUE | 0x2 | GV_ADDMULTI);
3201     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_PAUSE_SEEK)));
3202     SvREADONLY_on(sv);
3203   } while(0) /*@SWIG@*/;
3204   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3205     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_PAUSE_MEDIA_ERROR", TRUE | 0x2 | GV_ADDMULTI);
3206     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_PAUSE_MEDIA_ERROR)));
3207     SvREADONLY_on(sv);
3208   } while(0) /*@SWIG@*/;
3209   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3210     SV *sv = get_sv((char*) SWIG_prefix "NDMP9_MOVER_PAUSE_EOW", TRUE | 0x2 | GV_ADDMULTI);
3211     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(NDMP9_MOVER_PAUSE_EOW)));
3212     SvREADONLY_on(sv);
3213   } while(0) /*@SWIG@*/;
3214   ST(0) = &PL_sv_yes;
3215   XSRETURN(1);
3216 }
3217