git.gag.com Git - debian/amanda/blob - perl/Amanda/Xfer.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_DirectTCPAddr swig_types[0]
1478 #define SWIGTYPE_p_Xfer swig_types[1]
1479 #define SWIGTYPE_p_XferElement swig_types[2]
1480 #define SWIGTYPE_p_amglue_Source swig_types[3]
1481 #define SWIGTYPE_p_char swig_types[4]
1482 #define SWIGTYPE_p_double swig_types[5]
1483 #define SWIGTYPE_p_float swig_types[6]
1484 #define SWIGTYPE_p_gsize swig_types[7]
1485 #define SWIGTYPE_p_guint32 swig_types[8]
1486 #define SWIGTYPE_p_guint64 swig_types[9]
1487 #define SWIGTYPE_p_int swig_types[10]
1488 #define SWIGTYPE_p_p_XferElement swig_types[11]
1489 #define SWIGTYPE_p_p_char swig_types[12]
1490 #define SWIGTYPE_p_p_void swig_types[13]
1491 #define SWIGTYPE_p_unsigned_char swig_types[14]
1492 static swig_type_info *swig_types[16];
1493 static swig_module_info swig_module = {swig_types, 15, 0, 0, 0, 0};
1494 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1495 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1496
1497 /* -------- TYPES TABLE (END) -------- */
1498
1499 #define SWIG_init    boot_Amanda__Xfer
1500
1501 #define SWIG_name   "Amanda::Xferc::boot_Amanda__Xfer"
1502 #define SWIG_prefix "Amanda::Xferc::"
1503
1504 #define SWIGVERSION 0x010339
1505 #define SWIG_VERSION SWIGVERSION
1506
1507
1508 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1509 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1510
1511
1512 #ifdef __cplusplus
1513 extern "C"
1514 #endif
1515 #ifndef PERL_OBJECT
1516 #ifndef MULTIPLICITY
1517 SWIGEXPORT void SWIG_init (CV* cv);
1518 #else
1519 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1520 #endif
1521 #else
1522 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1523 #endif
1524
1525
1526 #include "amglue.h"
1527
1528
1529 #include "amglue.h"
1530
1531
1532 #include "amglue.h"
1533
1534
1535 #include "glib-util.h"
1536 #include "amxfer.h"
1537
1538
1539 SWIGINTERNINLINE SV *
1540 SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
1541 {
1542   SV *obj = sv_newmortal();
1543   sv_setiv(obj, (IV) value);
1544   return obj;
1545 }
1546
1547
1548 SWIGINTERNINLINE SV *
1549 SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
1550 {
1551   return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
1552 }
1553
1554
1555 /* Given an XMsg, return a hashref representing the message as a pure-perl
1556  * object.  The object is new, has refcount 1, and is totally independent of
1557  * the underlying XMsg.
1558  *
1559  * Reflecting the XMsg directly into Perl avoids the need to reference-count
1560  * the XMsg objects themselves, which can simply be freed after a callback
1561  * completes.  The overhead of creating a hash is likely equivalent to or
1562  * less than the overhead that would be consumed with SWIG's swig_$field_get
1563  * accessors, assuming that perl code examines most of the fields in a message.
1564  *
1565  * @param msg: the message to represent
1566  * @returns: a perl SV
1567  */
1568 static SV *
1569 new_sv_for_xmsg(
1570     XMsg *msg)
1571 {
1572     static HV *amanda_xfer_msg_stash = NULL;
1573     HV *hash = newHV();
1574     SV *rv = newRV_noinc((SV *)hash);
1575
1576     /* bless the rv as an Amanda::Xfer::Msg object */
1577     if (!amanda_xfer_msg_stash) {
1578         amanda_xfer_msg_stash = gv_stashpv("Amanda::Xfer::Msg", GV_ADD);
1579     }
1580     sv_bless(rv, amanda_xfer_msg_stash);
1581
1582     /* TODO: consider optimizing by precomputing the hash values of
1583      * the keys? */
1584
1585     /* elt */
1586     hv_store(hash, "elt", 3, new_sv_for_xfer_element(msg->elt), 0);
1587
1588     /* type */
1589     hv_store(hash, "type", 4, newSViv(msg->type), 0);
1590
1591     /* type */
1592     hv_store(hash, "version", 7, newSViv(msg->version), 0);
1593
1594     /* message */
1595     if (msg->message)
1596         hv_store(hash, "message", 7, newSVpv(msg->message, 0), 0);
1597
1598     /* successful */
1599     hv_store(hash, "successful", 10, newSViv(msg->successful), 0);
1600
1601     /* eom */
1602     hv_store(hash, "eom", 3, newSViv(msg->eom), 0);
1603
1604     /* eof */
1605     hv_store(hash, "eof", 3, newSViv(msg->eof), 0);
1606
1607     /* size */
1608     hv_store(hash, "size", 4, amglue_newSVu64(msg->size), 0);
1609
1610     /* duration */
1611     hv_store(hash, "duration", 8, newSVnv(msg->duration), 0);
1612
1613     /* partnum */
1614     hv_store(hash, "partnum", 7, amglue_newSVu64(msg->partnum), 0);
1615
1616     /* fileno */
1617     hv_store(hash, "fileno", 6, amglue_newSVu64(msg->fileno), 0);
1618
1619     return rv;
1620 }
1621
1622
1623 #include <limits.h>
1624 #if !defined(SWIG_NO_LLONG_MAX)
1625 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1626 #   define LLONG_MAX __LONG_LONG_MAX__
1627 #   define LLONG_MIN (-LLONG_MAX - 1LL)
1628 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1629 # endif
1630 #endif
1631
1632
1633 SWIGINTERN int
1634 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1635 {
1636   if (SvNIOK(obj)) {
1637     if (val) *val = SvNV(obj);
1638     return SWIG_OK;
1639   } else if (SvIOK(obj)) {
1640     if (val) *val = (double) SvIV(obj);
1641     return SWIG_AddCast(SWIG_OK);
1642   } else {
1643     const char *nptr = SvPV_nolen(obj);
1644     if (nptr) {
1645       char *endptr;
1646       double v = strtod(nptr, &endptr);
1647       if (errno == ERANGE) {
1648         errno = 0;
1649         return SWIG_OverflowError;
1650       } else {
1651         if (*endptr == '\0') {
1652           if (val) *val = v;
1653           return SWIG_Str2NumCast(SWIG_OK);
1654         }
1655       }
1656     }
1657   }
1658   return SWIG_TypeError;
1659 }
1660
1661
1662 #include <float.h>
1663
1664
1665 #include <math.h>
1666
1667
1668 SWIGINTERNINLINE int
1669 SWIG_CanCastAsInteger(double *d, double min, double max) {
1670   double x = *d;
1671   if ((min <= x && x <= max)) {
1672    double fx = floor(x);
1673    double cx = ceil(x);
1674    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1675    if ((errno == EDOM) || (errno == ERANGE)) {
1676      errno = 0;
1677    } else {
1678      double summ, reps, diff;
1679      if (rd < x) {
1680        diff = x - rd;
1681      } else if (rd > x) {
1682        diff = rd - x;
1683      } else {
1684        return 1;
1685      }
1686      summ = rd + x;
1687      reps = diff/summ;
1688      if (reps < 8*DBL_EPSILON) {
1689        *d = rd;
1690        return 1;
1691      }
1692    }
1693   }
1694   return 0;
1695 }
1696
1697
1698 SWIGINTERN int
1699 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
1700 {
1701   if (SvUOK(obj)) {
1702     if (val) *val = SvUV(obj);
1703     return SWIG_OK;
1704   } else  if (SvIOK(obj)) {
1705     long v = SvIV(obj);
1706     if (v >= 0) {
1707       if (val) *val = v;
1708       return SWIG_OK;
1709     } else {
1710       return SWIG_OverflowError;
1711     }
1712   } else {
1713     int dispatch = 0;
1714     const char *nptr = SvPV_nolen(obj);
1715     if (nptr) {
1716       char *endptr;
1717       unsigned long v;
1718       errno = 0;
1719       v = strtoul(nptr, &endptr,0);
1720       if (errno == ERANGE) {
1721         errno = 0;
1722         return SWIG_OverflowError;
1723       } else {
1724         if (*endptr == '\0') {
1725           if (val) *val = v;
1726           return SWIG_Str2NumCast(SWIG_OK);
1727         }
1728       }
1729     }
1730     if (!dispatch) {
1731       double d;
1732       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1733       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
1734         if (val) *val = (unsigned long)(d);
1735         return res;
1736       }
1737     }
1738   }
1739   return SWIG_TypeError;
1740 }
1741
1742
1743 SWIGINTERN int
1744 SWIG_AsVal_unsigned_SS_int SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned int *val)
1745 {
1746   unsigned long v;
1747   int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1748   if (SWIG_IsOK(res)) {
1749     if ((v > UINT_MAX)) {
1750       return SWIG_OverflowError;
1751     } else {
1752       if (val) *val = (unsigned int)(v);
1753     }
1754   }
1755   return res;
1756 }
1757
1758
1759 SWIGINTERNINLINE SV *
1760 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1761 {
1762   SV *obj = sv_newmortal();
1763   if (carray) {
1764     sv_setpvn(obj, carray, size);
1765   } else {
1766     sv_setsv(obj, &PL_sv_undef);
1767   }
1768   return obj;
1769 }
1770
1771
1772 SWIGINTERNINLINE SV *
1773 SWIG_FromCharPtr(const char *cptr)
1774 {
1775   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1776 }
1777
1778
1779 /* SWIG wants to treat this as a function */
1780 #define xfer_get_status(xfer) ((xfer)->status)
1781
1782
1783 static gboolean same_elements(
1784         XferElement *a,
1785         XferElement *b)
1786 {
1787     return a == b;
1788 }
1789
1790
1791 SWIGINTERNINLINE int
1792 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
1793 {
1794   unsigned long v;
1795   int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
1796   if (SWIG_IsOK(res) && val) *val = (size_t)(v);
1797   return res;
1798 }
1799
1800
1801 SWIGINTERN int
1802 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1803 {
1804   if (SvIOK(obj)) {
1805     if (val) *val = SvIV(obj);
1806     return SWIG_OK;
1807   } else {
1808     int dispatch = 0;
1809     const char *nptr = SvPV_nolen(obj);
1810     if (nptr) {
1811       char *endptr;
1812       long v;
1813       errno = 0;
1814       v = strtol(nptr, &endptr,0);
1815       if (errno == ERANGE) {
1816         errno = 0;
1817         return SWIG_OverflowError;
1818       } else {
1819         if (*endptr == '\0') {
1820           if (val) *val = v;
1821           return SWIG_Str2NumCast(SWIG_OK);
1822         }
1823       }
1824     }
1825     if (!dispatch) {
1826       double d;
1827       int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1828       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1829         if (val) *val = (long)(d);
1830         return res;
1831       }
1832     }
1833   }
1834   return SWIG_TypeError;
1835 }
1836
1837
1838 SWIGINTERN int
1839 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1840 {
1841   long v;
1842   int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1843   if (SWIG_IsOK(res)) {
1844     if ((v < INT_MIN || v > INT_MAX)) {
1845       return SWIG_OverflowError;
1846     } else {
1847       if (val) *val = (int)(v);
1848     }
1849   }
1850   return res;
1851 }
1852
1853
1854 static DirectTCPAddr *
1855 xfer_source_directtcp_listen_get_addrs(XferElement *elt) {
1856     return elt->input_listen_addrs;
1857 }
1858
1859
1860 SWIGINTERN int
1861 SWIG_AsVal_unsigned_SS_char SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned char *val)
1862 {
1863   unsigned long v;
1864   int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1865   if (SWIG_IsOK(res)) {
1866     if ((v > UCHAR_MAX)) {
1867       return SWIG_OverflowError;
1868     } else {
1869       if (val) *val = (unsigned char)(v);
1870     }
1871   }
1872   return res;
1873 }
1874
1875
1876 static DirectTCPAddr *
1877 xfer_dest_directtcp_listen_get_addrs(XferElement *elt) {
1878     return elt->output_listen_addrs;
1879 }
1880
1881
1882 static gboolean
1883 xmsgsource_perl_callback(
1884     gpointer data,
1885     struct XMsg *msg,
1886     Xfer *xfer)
1887 {
1888     dSP;
1889     amglue_Source *src = (amglue_Source *)data;
1890     SV *src_sv = NULL;
1891     SV *msg_sv = NULL;
1892     SV *xfer_sv = NULL;
1893
1894     /* keep the source around long enough for the call to finish */
1895     amglue_source_ref(src);
1896     g_assert(src->callback_sv != NULL);
1897
1898     ENTER;
1899     SAVETMPS;
1900
1901     /* create a new SV pointing to 'src', and increase its refcount
1902      * accordingly. */
1903     amglue_source_ref(src);
1904     src_sv = SWIG_NewPointerObj(src, SWIGTYPE_p_amglue_Source,
1905                                  SWIG_OWNER | SWIG_SHADOW);
1906     SvREFCNT_inc(src_sv);
1907
1908     msg_sv = new_sv_for_xmsg(msg);
1909     xfer_sv = new_sv_for_xfer(xfer);
1910
1911     PUSHMARK(SP);
1912     XPUSHs(sv_2mortal(src_sv));
1913     XPUSHs(sv_2mortal(msg_sv));
1914     XPUSHs(sv_2mortal(xfer_sv));
1915     PUTBACK;
1916
1917     call_sv(src->callback_sv, G_EVAL|G_DISCARD);
1918
1919     FREETMPS;
1920     LEAVE;
1921
1922     /* we no longer need the src */
1923     amglue_source_unref(src);
1924     src = NULL;
1925
1926     /* these may be gone, so NULL them out */
1927     src_sv = NULL;
1928     msg_sv = NULL;
1929     xfer_sv = NULL;
1930
1931     /* check for an uncaught 'die'.  If we don't do this, then Perl will longjmp()
1932      * over the GMainLoop mechanics, leaving GMainLoop in an inconsistent (locked)
1933      * state. */
1934     if (SvTRUE(ERRSV)) {
1935         /* We handle this just the way the default 'die' handler in Amanda::Debug
1936          * does, but since Amanda's debug support may not yet be running, we back
1937          * it up with an exit() */
1938         g_critical("%s", SvPV_nolen(ERRSV));
1939         exit(1);
1940     }
1941
1942     return TRUE;
1943 }
1944
1945
1946 amglue_Source *
1947 xfer_get_amglue_source(
1948     Xfer *xfer)
1949 {
1950     return amglue_source_get(xfer_get_source(xfer),
1951         (GSourceFunc)xmsgsource_perl_callback);
1952 }
1953
1954 #ifdef __cplusplus
1955 extern "C" {
1956 #endif
1957
1958 #ifdef PERL_OBJECT
1959 #define MAGIC_CLASS _wrap_Amanda__Xfer_var::
1960 class _wrap_Amanda__Xfer_var : public CPerlObj {
1961 public:
1962 #else
1963 #define MAGIC_CLASS
1964 #endif
1965 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
1966     MAGIC_PPERL
1967     croak("Value is read-only.");
1968     return 0;
1969 }
1970
1971
1972 #ifdef PERL_OBJECT
1973 };
1974 #endif
1975
1976 #ifdef __cplusplus
1977 }
1978 #endif
1979
1980 #ifdef __cplusplus
1981 extern "C" {
1982 #endif
1983 XS(_wrap_xfer_new) {
1984   {
1985     XferElement **arg1 = (XferElement **) 0 ;
1986     unsigned int arg2 ;
1987     int argvi = 0;
1988     Xfer *result = 0 ;
1989     dXSARGS;
1990
1991     if ((items < 1) || (items > 1)) {
1992       SWIG_croak("Usage: xfer_new(elementlist,nelements);");
1993     }
1994     {
1995       AV *av;
1996       unsigned int i;
1997
1998       /* check that it's an arrayref */
1999       if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
2000         SWIG_exception(SWIG_TypeError, "Expected an arrayref");
2001       }
2002       av = (AV *)SvRV(ST(0));
2003
2004       /* allocate memory for arg1 */
2005       arg2 = av_len(av)+1; /* av_len(av) is like $#av */
2006       arg1 = g_new(XferElement *, arg2);
2007
2008       /* extract the underlying XferElement objects and add pointers to
2009            * them, "borrowing" the caller's references for the moment. */
2010       for (i = 0; i < arg2; i++) {
2011         SV **sv = av_fetch(av, i, 0);
2012         XferElement *elt = sv? xfer_element_from_sv(*sv):NULL;
2013
2014         if (!elt) {
2015           SWIG_exception(SWIG_TypeError, "Expected an arrayref of Amanda::Xfer::Element objects");
2016         }
2017         arg1[i] = elt;
2018       }
2019     }
2020     result = (Xfer *)xfer_new(arg1,arg2);
2021     {
2022       ST(argvi) = sv_2mortal(new_sv_for_xfer(result));
2023       argvi++;
2024     }
2025     {
2026       /* free the element vector allocated in the (in) typemap */
2027       g_free(arg1);
2028     }
2029     {
2030       xfer_unref(result);
2031     }
2032     XSRETURN(argvi);
2033   fail:
2034     {
2035       /* free the element vector allocated in the (in) typemap */
2036       g_free(arg1);
2037     }
2038     SWIG_croak_null();
2039   }
2040 }
2041
2042
2043 XS(_wrap_xfer_unref) {
2044   {
2045     Xfer *arg1 = (Xfer *) 0 ;
2046     int argvi = 0;
2047     dXSARGS;
2048
2049     if ((items < 1) || (items > 1)) {
2050       SWIG_croak("Usage: xfer_unref(Xfer *);");
2051     }
2052     {
2053       arg1 = xfer_from_sv(ST(0));
2054     }
2055     xfer_unref(arg1);
2056     ST(argvi) = sv_newmortal();
2057
2058     XSRETURN(argvi);
2059   fail:
2060
2061     SWIG_croak_null();
2062   }
2063 }
2064
2065
2066 XS(_wrap_xfer_get_status) {
2067   {
2068     Xfer *arg1 = (Xfer *) 0 ;
2069     int argvi = 0;
2070     xfer_status result;
2071     dXSARGS;
2072
2073     if ((items < 1) || (items > 1)) {
2074       SWIG_croak("Usage: xfer_get_status(xfer);");
2075     }
2076     {
2077       arg1 = xfer_from_sv(ST(0));
2078     }
2079     result = (xfer_status)xfer_get_status(arg1);
2080     {
2081       SV *for_stack;
2082       SP += argvi; PUTBACK;
2083       for_stack = sv_2mortal(amglue_newSVi64(result));
2084       SPAGAIN; SP -= argvi;
2085       ST(argvi) = for_stack;
2086       argvi++;
2087     }
2088
2089     XSRETURN(argvi);
2090   fail:
2091
2092     SWIG_croak_null();
2093   }
2094 }
2095
2096
2097 XS(_wrap_xfer_repr) {
2098   {
2099     Xfer *arg1 = (Xfer *) 0 ;
2100     int argvi = 0;
2101     char *result = 0 ;
2102     dXSARGS;
2103
2104     if ((items < 1) || (items > 1)) {
2105       SWIG_croak("Usage: xfer_repr(xfer);");
2106     }
2107     {
2108       arg1 = xfer_from_sv(ST(0));
2109     }
2110     result = (char *)xfer_repr(arg1);
2111     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2112
2113     XSRETURN(argvi);
2114   fail:
2115
2116     SWIG_croak_null();
2117   }
2118 }
2119
2120
2121 XS(_wrap_xfer_start) {
2122   {
2123     Xfer *arg1 = (Xfer *) 0 ;
2124     int argvi = 0;
2125     dXSARGS;
2126
2127     if ((items < 1) || (items > 1)) {
2128       SWIG_croak("Usage: xfer_start(xfer);");
2129     }
2130     {
2131       arg1 = xfer_from_sv(ST(0));
2132     }
2133     xfer_start(arg1);
2134     ST(argvi) = sv_newmortal();
2135
2136     XSRETURN(argvi);
2137   fail:
2138
2139     SWIG_croak_null();
2140   }
2141 }
2142
2143
2144 XS(_wrap_xfer_cancel) {
2145   {
2146     Xfer *arg1 = (Xfer *) 0 ;
2147     int argvi = 0;
2148     dXSARGS;
2149
2150     if ((items < 1) || (items > 1)) {
2151       SWIG_croak("Usage: xfer_cancel(xfer);");
2152     }
2153     {
2154       arg1 = xfer_from_sv(ST(0));
2155     }
2156     xfer_cancel(arg1);
2157     ST(argvi) = sv_newmortal();
2158
2159     XSRETURN(argvi);
2160   fail:
2161
2162     SWIG_croak_null();
2163   }
2164 }
2165
2166
2167 XS(_wrap_xfer_element_unref) {
2168   {
2169     XferElement *arg1 = (XferElement *) 0 ;
2170     int argvi = 0;
2171     dXSARGS;
2172
2173     if ((items < 1) || (items > 1)) {
2174       SWIG_croak("Usage: xfer_element_unref(elt);");
2175     }
2176     {
2177       arg1 = xfer_element_from_sv(ST(0));
2178     }
2179     xfer_element_unref(arg1);
2180     ST(argvi) = sv_newmortal();
2181
2182     XSRETURN(argvi);
2183   fail:
2184
2185     SWIG_croak_null();
2186   }
2187 }
2188
2189
2190 XS(_wrap_xfer_element_repr) {
2191   {
2192     XferElement *arg1 = (XferElement *) 0 ;
2193     int argvi = 0;
2194     char *result = 0 ;
2195     dXSARGS;
2196
2197     if ((items < 1) || (items > 1)) {
2198       SWIG_croak("Usage: xfer_element_repr(elt);");
2199     }
2200     {
2201       arg1 = xfer_element_from_sv(ST(0));
2202     }
2203     result = (char *)xfer_element_repr(arg1);
2204     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2205
2206     XSRETURN(argvi);
2207   fail:
2208
2209     SWIG_croak_null();
2210   }
2211 }
2212
2213
2214 XS(_wrap_same_elements) {
2215   {
2216     XferElement *arg1 = (XferElement *) 0 ;
2217     XferElement *arg2 = (XferElement *) 0 ;
2218     int argvi = 0;
2219     gboolean result;
2220     dXSARGS;
2221
2222     if ((items < 2) || (items > 2)) {
2223       SWIG_croak("Usage: same_elements(a,b);");
2224     }
2225     {
2226       arg1 = xfer_element_from_sv(ST(0));
2227     }
2228     {
2229       arg2 = xfer_element_from_sv(ST(1));
2230     }
2231     result = (gboolean)same_elements(arg1,arg2);
2232     {
2233       if (result)
2234       ST(argvi) = &PL_sv_yes;
2235       else
2236       ST(argvi) = &PL_sv_no;
2237       argvi++;
2238     }
2239
2240
2241     XSRETURN(argvi);
2242   fail:
2243
2244
2245     SWIG_croak_null();
2246   }
2247 }
2248
2249
2250 XS(_wrap_xfer_source_random) {
2251   {
2252     guint64 arg1 ;
2253     guint32 arg2 ;
2254     int argvi = 0;
2255     XferElement *result = 0 ;
2256     dXSARGS;
2257
2258     if ((items < 2) || (items > 2)) {
2259       SWIG_croak("Usage: xfer_source_random(length,seed);");
2260     }
2261     {
2262       arg1 = amglue_SvU64(ST(0));
2263     }
2264     {
2265       arg2 = amglue_SvU32(ST(1));
2266     }
2267     result = (XferElement *)xfer_source_random(arg1,arg2);
2268     {
2269       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2270       argvi++;
2271     }
2272     {
2273       xfer_element_unref(result);
2274     }
2275     XSRETURN(argvi);
2276   fail:
2277     SWIG_croak_null();
2278   }
2279 }
2280
2281
2282 XS(_wrap_xfer_source_random_get_seed) {
2283   {
2284     XferElement *arg1 = (XferElement *) 0 ;
2285     int argvi = 0;
2286     guint32 result;
2287     dXSARGS;
2288
2289     if ((items < 1) || (items > 1)) {
2290       SWIG_croak("Usage: xfer_source_random_get_seed(self);");
2291     }
2292     {
2293       arg1 = xfer_element_from_sv(ST(0));
2294     }
2295     result = xfer_source_random_get_seed(arg1);
2296     {
2297       SV *for_stack;
2298       SP += argvi; PUTBACK;
2299       for_stack = sv_2mortal(amglue_newSVu64(result));
2300       SPAGAIN; SP -= argvi;
2301       ST(argvi) = for_stack;
2302       argvi++;
2303     }
2304
2305     XSRETURN(argvi);
2306   fail:
2307
2308     SWIG_croak_null();
2309   }
2310 }
2311
2312
2313 XS(_wrap_xfer_source_pattern) {
2314   {
2315     guint64 arg1 ;
2316     void *arg2 = (void *) 0 ;
2317     size_t arg3 ;
2318     int argvi = 0;
2319     XferElement *result = 0 ;
2320     dXSARGS;
2321
2322     if ((items < 2) || (items > 2)) {
2323       SWIG_croak("Usage: xfer_source_pattern(length,pattern,pattern_length);");
2324     }
2325     {
2326       arg1 = amglue_SvU64(ST(0));
2327     }
2328     {
2329       size_t len;
2330       char * pat;
2331
2332       pat = SvPV(ST(1), len);
2333       arg2 = g_memdup(pat, len);
2334       arg3 = len;
2335     }
2336     result = (XferElement *)xfer_source_pattern(arg1,arg2,arg3);
2337     {
2338       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2339       argvi++;
2340     }
2341     {
2342       xfer_element_unref(result);
2343     }
2344     XSRETURN(argvi);
2345   fail:
2346     SWIG_croak_null();
2347   }
2348 }
2349
2350
2351 XS(_wrap_xfer_source_fd) {
2352   {
2353     int arg1 ;
2354     int argvi = 0;
2355     XferElement *result = 0 ;
2356     dXSARGS;
2357
2358     if ((items < 1) || (items > 1)) {
2359       SWIG_croak("Usage: xfer_source_fd(fd);");
2360     }
2361     {
2362       IO *io = NULL;
2363       PerlIO *pio = NULL;
2364       int fd = -1;
2365
2366       if (SvIOK(ST(0))) {
2367         /* plain old integer */
2368         arg1 = SvIV(ST(0));
2369       } else {
2370         /* try extracting as filehandle */
2371
2372         /* note: sv_2io may call die() */
2373         io = sv_2io(ST(0));
2374         if (io) {
2375           pio = IoIFP(io);
2376         }
2377         if (pio) {
2378           fd = PerlIO_fileno(pio);
2379         }
2380         if (fd >= 0) {
2381           arg1 = fd;
2382         } else {
2383           SWIG_exception(SWIG_TypeError, "Expected integer file descriptor "
2384             "or file handle for argument 1");
2385         }
2386       }
2387     }
2388     result = (XferElement *)xfer_source_fd(arg1);
2389     {
2390       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2391       argvi++;
2392     }
2393
2394     {
2395       xfer_element_unref(result);
2396     }
2397     XSRETURN(argvi);
2398   fail:
2399
2400     SWIG_croak_null();
2401   }
2402 }
2403
2404
2405 XS(_wrap_xfer_source_directtcp_listen) {
2406   {
2407     int argvi = 0;
2408     XferElement *result = 0 ;
2409     dXSARGS;
2410
2411     if ((items < 0) || (items > 0)) {
2412       SWIG_croak("Usage: xfer_source_directtcp_listen();");
2413     }
2414     result = (XferElement *)xfer_source_directtcp_listen();
2415     {
2416       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2417       argvi++;
2418     }
2419     {
2420       xfer_element_unref(result);
2421     }
2422     XSRETURN(argvi);
2423   fail:
2424     SWIG_croak_null();
2425   }
2426 }
2427
2428
2429 XS(_wrap_xfer_source_directtcp_listen_get_addrs) {
2430   {
2431     XferElement *arg1 = (XferElement *) 0 ;
2432     int argvi = 0;
2433     DirectTCPAddr *result = 0 ;
2434     dXSARGS;
2435
2436     if ((items < 1) || (items > 1)) {
2437       SWIG_croak("Usage: xfer_source_directtcp_listen_get_addrs(elt);");
2438     }
2439     {
2440       arg1 = xfer_element_from_sv(ST(0));
2441     }
2442     result = (DirectTCPAddr *)xfer_source_directtcp_listen_get_addrs(arg1);
2443     {
2444       /* we assume this is an *array* of addresses, and return an arrayref or, if
2445            * the result is NULL, undef. */
2446       DirectTCPAddr *iter = result;
2447       AV *av;
2448       int i;
2449
2450       i = 0;
2451       av = newAV();
2452       while (iter && iter->ipv4) {
2453         struct in_addr in;
2454         char *addr;
2455         AV *tuple;
2456
2457         in.s_addr = htonl(iter->ipv4);
2458         addr = inet_ntoa(in);
2459
2460         tuple = newAV();
2461         g_assert(NULL != av_store(tuple, 0,
2462             newSVpv(addr, 0)));
2463         g_assert(NULL != av_store(tuple, 1, newSViv(iter->port)));
2464         g_assert(NULL != av_store(av, i++, newRV_noinc((SV *)tuple)));
2465         iter++;
2466       }
2467
2468       ST(argvi) = newRV_noinc((SV *)av);
2469       argvi++;
2470     }
2471
2472     XSRETURN(argvi);
2473   fail:
2474
2475     SWIG_croak_null();
2476   }
2477 }
2478
2479
2480 XS(_wrap_xfer_source_directtcp_connect) {
2481   {
2482     DirectTCPAddr *arg1 = (DirectTCPAddr *) 0 ;
2483     int argvi = 0;
2484     XferElement *result = 0 ;
2485     dXSARGS;
2486
2487     if ((items < 1) || (items > 1)) {
2488       SWIG_croak("Usage: xfer_source_directtcp_connect(addrs);");
2489     }
2490     {
2491       AV *addrs_av;
2492       int num_addrs, i;
2493
2494       if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
2495         SWIG_exception_fail(SWIG_TypeError, "must provide an arrayref of DirectTCPAddrs");
2496       }
2497       addrs_av = (AV *)SvRV(ST(0));
2498       num_addrs = av_len(addrs_av)+1;
2499
2500       arg1 = g_new0(DirectTCPAddr, num_addrs);
2501
2502       for (i = 0; i < num_addrs; i++) {
2503         SV **svp = av_fetch(addrs_av, i, 0);
2504         AV *addr_av;
2505         struct in_addr addr;
2506         IV port;
2507
2508         if (!svp || !SvROK(*svp) || SvTYPE(SvRV(*svp)) != SVt_PVAV
2509           || av_len((AV *)SvRV(*svp))+1 != 2) {
2510           SWIG_exception_fail(SWIG_TypeError, "each DirectTCPAddr must be a 2-element arrayref");
2511         }
2512
2513         addr_av = (AV *)SvRV(*svp);
2514
2515         /* get address */
2516         svp = av_fetch(addr_av, 0, 0);
2517         if (!svp || !SvPOK(*svp) || !inet_aton(SvPV_nolen(*svp), &addr)) {
2518           SWIG_exception_fail(SWIG_TypeError, "invalid IPv4 addr in address");
2519         }
2520         arg1[i].ipv4 = ntohl(addr.s_addr);
2521
2522         /* get port */
2523         svp = av_fetch(addr_av, 1, 0);
2524         if (!svp || !SvIOK(*svp) || (port = SvIV(*svp)) <= 0 || port >= 65536) {
2525           SWIG_exception_fail(SWIG_TypeError, "invalid port in address");
2526         }
2527         arg1[i].port = (guint16)port;
2528       }
2529     }
2530     result = (XferElement *)xfer_source_directtcp_connect(arg1);
2531     {
2532       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2533       argvi++;
2534     }
2535
2536     {
2537       xfer_element_unref(result);
2538     }
2539     XSRETURN(argvi);
2540   fail:
2541
2542     SWIG_croak_null();
2543   }
2544 }
2545
2546
2547 XS(_wrap_xfer_filter_xor) {
2548   {
2549     unsigned char arg1 ;
2550     unsigned char val1 ;
2551     int ecode1 = 0 ;
2552     int argvi = 0;
2553     XferElement *result = 0 ;
2554     dXSARGS;
2555
2556     if ((items < 1) || (items > 1)) {
2557       SWIG_croak("Usage: xfer_filter_xor(xor_key);");
2558     }
2559     ecode1 = SWIG_AsVal_unsigned_SS_char SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2560     if (!SWIG_IsOK(ecode1)) {
2561       SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xfer_filter_xor" "', argument " "1"" of type '" "unsigned char""'");
2562     }
2563     arg1 = (unsigned char)(val1);
2564     result = (XferElement *)xfer_filter_xor(arg1);
2565     {
2566       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2567       argvi++;
2568     }
2569
2570     {
2571       xfer_element_unref(result);
2572     }
2573     XSRETURN(argvi);
2574   fail:
2575
2576     SWIG_croak_null();
2577   }
2578 }
2579
2580
2581 XS(_wrap_xfer_filter_process) {
2582   {
2583     gchar **arg1 = (gchar **) 0 ;
2584     gboolean arg2 ;
2585     int argvi = 0;
2586     XferElement *result = 0 ;
2587     dXSARGS;
2588
2589     if ((items < 2) || (items > 2)) {
2590       SWIG_croak("Usage: xfer_filter_process(argv,need_root);");
2591     }
2592     {
2593       AV *av;
2594       unsigned int len;
2595       unsigned int i;
2596
2597       /* check that it's an arrayref */
2598       if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
2599         SWIG_exception(SWIG_TypeError, "Expected a non-empty arrayref");
2600       }
2601       av = (AV *)SvRV(ST(0));
2602
2603       /* allocate memory for arg1 */
2604       len = av_len(av)+1; /* av_len(av) is like $#av */
2605       if (!len) {
2606         SWIG_exception(SWIG_TypeError, "Expected a non-empty arrayref");
2607       }
2608       arg1 = g_new0(gchar *, len+1);
2609
2610       for (i = 0; i < len; i++) {
2611         SV **sv = av_fetch(av, i, 0);
2612         g_assert(sv != NULL);
2613         arg1[i] = g_strdup(SvPV_nolen(*sv));
2614       }
2615
2616       /* final element is already NULL due to g_new0; xfer_filter_process takes
2617            * care of freeing this array, so we don't have to */
2618     }
2619     {
2620       if (sizeof(signed int) == 1) {
2621         arg2 = amglue_SvI8(ST(1));
2622       } else if (sizeof(signed int) == 2) {
2623         arg2 = amglue_SvI16(ST(1));
2624       } else if (sizeof(signed int) == 4) {
2625         arg2 = amglue_SvI32(ST(1));
2626       } else if (sizeof(signed int) == 8) {
2627         arg2 = amglue_SvI64(ST(1));
2628       } else {
2629         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2630       }
2631     }
2632     result = (XferElement *)xfer_filter_process(arg1,arg2);
2633     {
2634       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2635       argvi++;
2636     }
2637
2638
2639     {
2640       xfer_element_unref(result);
2641     }
2642     XSRETURN(argvi);
2643   fail:
2644
2645
2646     SWIG_croak_null();
2647   }
2648 }
2649
2650
2651 XS(_wrap_xfer_dest_null) {
2652   {
2653     guint32 arg1 ;
2654     int argvi = 0;
2655     XferElement *result = 0 ;
2656     dXSARGS;
2657
2658     if ((items < 1) || (items > 1)) {
2659       SWIG_croak("Usage: xfer_dest_null(prng_seed);");
2660     }
2661     {
2662       arg1 = amglue_SvU32(ST(0));
2663     }
2664     result = (XferElement *)xfer_dest_null(arg1);
2665     {
2666       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2667       argvi++;
2668     }
2669     {
2670       xfer_element_unref(result);
2671     }
2672     XSRETURN(argvi);
2673   fail:
2674     SWIG_croak_null();
2675   }
2676 }
2677
2678
2679 XS(_wrap_xfer_dest_buffer) {
2680   {
2681     gsize arg1 ;
2682     int argvi = 0;
2683     XferElement *result = 0 ;
2684     dXSARGS;
2685
2686     if ((items < 1) || (items > 1)) {
2687       SWIG_croak("Usage: xfer_dest_buffer(max_size);");
2688     }
2689     {
2690       if (sizeof(gsize) == 1) {
2691         arg1 = amglue_SvU8(ST(0));
2692       } else if (sizeof(gsize) == 2) {
2693         arg1 = amglue_SvU16(ST(0));
2694       } else if (sizeof(gsize) == 4) {
2695         arg1 = amglue_SvU32(ST(0));
2696       } else if (sizeof(gsize) == 8) {
2697         arg1 = amglue_SvU64(ST(0));
2698       } else {
2699         croak("Unexpected gsize >64 bits?"); /* should be optimized out unless sizeof(gsize) > 8 */
2700       }
2701     }
2702     result = (XferElement *)xfer_dest_buffer(arg1);
2703     {
2704       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2705       argvi++;
2706     }
2707     {
2708       xfer_element_unref(result);
2709     }
2710     XSRETURN(argvi);
2711   fail:
2712     SWIG_croak_null();
2713   }
2714 }
2715
2716
2717 XS(_wrap_xfer_dest_buffer_get) {
2718   {
2719     XferElement *arg1 = (XferElement *) 0 ;
2720     gpointer *arg2 = (gpointer *) 0 ;
2721     gsize *arg3 = (gsize *) 0 ;
2722     gpointer temp2 = 0 ;
2723     gsize tempn2 ;
2724     int argvi = 0;
2725     dXSARGS;
2726
2727     arg2 = &temp2; arg3 = &tempn2;
2728     if ((items < 1) || (items > 1)) {
2729       SWIG_croak("Usage: xfer_dest_buffer_get(elt,size);");
2730     }
2731     {
2732       arg1 = xfer_element_from_sv(ST(0));
2733     }
2734     xfer_dest_buffer_get(arg1,arg2,arg3);
2735     ST(argvi) = sv_newmortal();
2736     if (*arg2) {
2737       if (argvi >= items) EXTEND(sp,1);  ST(argvi) = SWIG_FromCharPtrAndSize(*arg2,*arg3); argvi++  ;
2738       ;
2739     }
2740
2741
2742     XSRETURN(argvi);
2743   fail:
2744
2745
2746     SWIG_croak_null();
2747   }
2748 }
2749
2750
2751 XS(_wrap_xfer_dest_fd) {
2752   {
2753     int arg1 ;
2754     int argvi = 0;
2755     XferElement *result = 0 ;
2756     dXSARGS;
2757
2758     if ((items < 1) || (items > 1)) {
2759       SWIG_croak("Usage: xfer_dest_fd(fd);");
2760     }
2761     {
2762       IO *io = NULL;
2763       PerlIO *pio = NULL;
2764       int fd = -1;
2765
2766       if (SvIOK(ST(0))) {
2767         /* plain old integer */
2768         arg1 = SvIV(ST(0));
2769       } else {
2770         /* try extracting as filehandle */
2771
2772         /* note: sv_2io may call die() */
2773         io = sv_2io(ST(0));
2774         if (io) {
2775           pio = IoIFP(io);
2776         }
2777         if (pio) {
2778           fd = PerlIO_fileno(pio);
2779         }
2780         if (fd >= 0) {
2781           arg1 = fd;
2782         } else {
2783           SWIG_exception(SWIG_TypeError, "Expected integer file descriptor "
2784             "or file handle for argument 1");
2785         }
2786       }
2787     }
2788     result = (XferElement *)xfer_dest_fd(arg1);
2789     {
2790       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2791       argvi++;
2792     }
2793
2794     {
2795       xfer_element_unref(result);
2796     }
2797     XSRETURN(argvi);
2798   fail:
2799
2800     SWIG_croak_null();
2801   }
2802 }
2803
2804
2805 XS(_wrap_xfer_dest_directtcp_listen) {
2806   {
2807     int argvi = 0;
2808     XferElement *result = 0 ;
2809     dXSARGS;
2810
2811     if ((items < 0) || (items > 0)) {
2812       SWIG_croak("Usage: xfer_dest_directtcp_listen();");
2813     }
2814     result = (XferElement *)xfer_dest_directtcp_listen();
2815     {
2816       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2817       argvi++;
2818     }
2819     {
2820       xfer_element_unref(result);
2821     }
2822     XSRETURN(argvi);
2823   fail:
2824     SWIG_croak_null();
2825   }
2826 }
2827
2828
2829 XS(_wrap_xfer_dest_directtcp_listen_get_addrs) {
2830   {
2831     XferElement *arg1 = (XferElement *) 0 ;
2832     int argvi = 0;
2833     DirectTCPAddr *result = 0 ;
2834     dXSARGS;
2835
2836     if ((items < 1) || (items > 1)) {
2837       SWIG_croak("Usage: xfer_dest_directtcp_listen_get_addrs(elt);");
2838     }
2839     {
2840       arg1 = xfer_element_from_sv(ST(0));
2841     }
2842     result = (DirectTCPAddr *)xfer_dest_directtcp_listen_get_addrs(arg1);
2843     {
2844       /* we assume this is an *array* of addresses, and return an arrayref or, if
2845            * the result is NULL, undef. */
2846       DirectTCPAddr *iter = result;
2847       AV *av;
2848       int i;
2849
2850       i = 0;
2851       av = newAV();
2852       while (iter && iter->ipv4) {
2853         struct in_addr in;
2854         char *addr;
2855         AV *tuple;
2856
2857         in.s_addr = htonl(iter->ipv4);
2858         addr = inet_ntoa(in);
2859
2860         tuple = newAV();
2861         g_assert(NULL != av_store(tuple, 0,
2862             newSVpv(addr, 0)));
2863         g_assert(NULL != av_store(tuple, 1, newSViv(iter->port)));
2864         g_assert(NULL != av_store(av, i++, newRV_noinc((SV *)tuple)));
2865         iter++;
2866       }
2867
2868       ST(argvi) = newRV_noinc((SV *)av);
2869       argvi++;
2870     }
2871
2872     XSRETURN(argvi);
2873   fail:
2874
2875     SWIG_croak_null();
2876   }
2877 }
2878
2879
2880 XS(_wrap_xfer_dest_directtcp_connect) {
2881   {
2882     DirectTCPAddr *arg1 = (DirectTCPAddr *) 0 ;
2883     int argvi = 0;
2884     XferElement *result = 0 ;
2885     dXSARGS;
2886
2887     if ((items < 1) || (items > 1)) {
2888       SWIG_croak("Usage: xfer_dest_directtcp_connect(addrs);");
2889     }
2890     {
2891       AV *addrs_av;
2892       int num_addrs, i;
2893
2894       if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
2895         SWIG_exception_fail(SWIG_TypeError, "must provide an arrayref of DirectTCPAddrs");
2896       }
2897       addrs_av = (AV *)SvRV(ST(0));
2898       num_addrs = av_len(addrs_av)+1;
2899
2900       arg1 = g_new0(DirectTCPAddr, num_addrs);
2901
2902       for (i = 0; i < num_addrs; i++) {
2903         SV **svp = av_fetch(addrs_av, i, 0);
2904         AV *addr_av;
2905         struct in_addr addr;
2906         IV port;
2907
2908         if (!svp || !SvROK(*svp) || SvTYPE(SvRV(*svp)) != SVt_PVAV
2909           || av_len((AV *)SvRV(*svp))+1 != 2) {
2910           SWIG_exception_fail(SWIG_TypeError, "each DirectTCPAddr must be a 2-element arrayref");
2911         }
2912
2913         addr_av = (AV *)SvRV(*svp);
2914
2915         /* get address */
2916         svp = av_fetch(addr_av, 0, 0);
2917         if (!svp || !SvPOK(*svp) || !inet_aton(SvPV_nolen(*svp), &addr)) {
2918           SWIG_exception_fail(SWIG_TypeError, "invalid IPv4 addr in address");
2919         }
2920         arg1[i].ipv4 = ntohl(addr.s_addr);
2921
2922         /* get port */
2923         svp = av_fetch(addr_av, 1, 0);
2924         if (!svp || !SvIOK(*svp) || (port = SvIV(*svp)) <= 0 || port >= 65536) {
2925           SWIG_exception_fail(SWIG_TypeError, "invalid port in address");
2926         }
2927         arg1[i].port = (guint16)port;
2928       }
2929     }
2930     result = (XferElement *)xfer_dest_directtcp_connect(arg1);
2931     {
2932       ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2933       argvi++;
2934     }
2935
2936     {
2937       xfer_element_unref(result);
2938     }
2939     XSRETURN(argvi);
2940   fail:
2941
2942     SWIG_croak_null();
2943   }
2944 }
2945
2946
2947 XS(_wrap_xfer_get_amglue_source) {
2948   {
2949     Xfer *arg1 = (Xfer *) 0 ;
2950     int argvi = 0;
2951     amglue_Source *result = 0 ;
2952     dXSARGS;
2953
2954     if ((items < 1) || (items > 1)) {
2955       SWIG_croak("Usage: xfer_get_amglue_source(xfer);");
2956     }
2957     {
2958       arg1 = xfer_from_sv(ST(0));
2959     }
2960     result = (amglue_Source *)xfer_get_amglue_source(arg1);
2961     ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_amglue_Source, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
2962
2963     XSRETURN(argvi);
2964   fail:
2965
2966     SWIG_croak_null();
2967   }
2968 }
2969
2970
2971
2972 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
2973
2974 static swig_type_info _swigt__p_DirectTCPAddr = {"_p_DirectTCPAddr", "DirectTCPAddr *", 0, 0, (void*)0, 0};
2975 static swig_type_info _swigt__p_Xfer = {"_p_Xfer", "Xfer *", 0, 0, (void*)0, 0};
2976 static swig_type_info _swigt__p_XferElement = {"_p_XferElement", "XferElement *", 0, 0, (void*)0, 0};
2977 static swig_type_info _swigt__p_amglue_Source = {"_p_amglue_Source", "struct amglue_Source *|amglue_Source *", 0, 0, (void*)"Amanda::MainLoop::Source", 0};
2978 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
2979 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
2980 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
2981 static swig_type_info _swigt__p_gsize = {"_p_gsize", "gsize *", 0, 0, (void*)0, 0};
2982 static swig_type_info _swigt__p_guint32 = {"_p_guint32", "guint32 *", 0, 0, (void*)0, 0};
2983 static swig_type_info _swigt__p_guint64 = {"_p_guint64", "guint64 *", 0, 0, (void*)0, 0};
2984 static swig_type_info _swigt__p_int = {"_p_int", "xmsg_type *|int *|GIOCondition *|xfer_status *|gboolean *", 0, 0, (void*)0, 0};
2985 static swig_type_info _swigt__p_p_XferElement = {"_p_p_XferElement", "XferElement **", 0, 0, (void*)0, 0};
2986 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **|gchar **", 0, 0, (void*)0, 0};
2987 static swig_type_info _swigt__p_p_void = {"_p_p_void", "gpointer *|void **", 0, 0, (void*)0, 0};
2988 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
2989
2990 static swig_type_info *swig_type_initial[] = {
2991   &_swigt__p_DirectTCPAddr,
2992   &_swigt__p_Xfer,
2993   &_swigt__p_XferElement,
2994   &_swigt__p_amglue_Source,
2995   &_swigt__p_char,
2996   &_swigt__p_double,
2997   &_swigt__p_float,
2998   &_swigt__p_gsize,
2999   &_swigt__p_guint32,
3000   &_swigt__p_guint64,
3001   &_swigt__p_int,
3002   &_swigt__p_p_XferElement,
3003   &_swigt__p_p_char,
3004   &_swigt__p_p_void,
3005   &_swigt__p_unsigned_char,
3006 };
3007
3008 static swig_cast_info _swigc__p_DirectTCPAddr[] = {  {&_swigt__p_DirectTCPAddr, 0, 0, 0},{0, 0, 0, 0}};
3009 static swig_cast_info _swigc__p_Xfer[] = {  {&_swigt__p_Xfer, 0, 0, 0},{0, 0, 0, 0}};
3010 static swig_cast_info _swigc__p_XferElement[] = {  {&_swigt__p_XferElement, 0, 0, 0},{0, 0, 0, 0}};
3011 static swig_cast_info _swigc__p_amglue_Source[] = {  {&_swigt__p_amglue_Source, 0, 0, 0},{0, 0, 0, 0}};
3012 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3013 static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
3014 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
3015 static swig_cast_info _swigc__p_gsize[] = {  {&_swigt__p_gsize, 0, 0, 0},{0, 0, 0, 0}};
3016 static swig_cast_info _swigc__p_guint32[] = {  {&_swigt__p_guint32, 0, 0, 0},{0, 0, 0, 0}};
3017 static swig_cast_info _swigc__p_guint64[] = {  {&_swigt__p_guint64, 0, 0, 0},{0, 0, 0, 0}};
3018 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
3019 static swig_cast_info _swigc__p_p_XferElement[] = {  {&_swigt__p_p_XferElement, 0, 0, 0},{0, 0, 0, 0}};
3020 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
3021 static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
3022 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
3023
3024 static swig_cast_info *swig_cast_initial[] = {
3025   _swigc__p_DirectTCPAddr,
3026   _swigc__p_Xfer,
3027   _swigc__p_XferElement,
3028   _swigc__p_amglue_Source,
3029   _swigc__p_char,
3030   _swigc__p_double,
3031   _swigc__p_float,
3032   _swigc__p_gsize,
3033   _swigc__p_guint32,
3034   _swigc__p_guint64,
3035   _swigc__p_int,
3036   _swigc__p_p_XferElement,
3037   _swigc__p_p_char,
3038   _swigc__p_p_void,
3039   _swigc__p_unsigned_char,
3040 };
3041
3042
3043 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3044
3045 static swig_constant_info swig_constants[] = {
3046 {0,0,0,0,0,0}
3047 };
3048 #ifdef __cplusplus
3049 }
3050 #endif
3051 static swig_variable_info swig_variables[] = {
3052 {0,0,0,0}
3053 };
3054 static swig_command_info swig_commands[] = {
3055 {"Amanda::Xferc::xfer_new", _wrap_xfer_new},
3056 {"Amanda::Xferc::xfer_unref", _wrap_xfer_unref},
3057 {"Amanda::Xferc::xfer_get_status", _wrap_xfer_get_status},
3058 {"Amanda::Xferc::xfer_repr", _wrap_xfer_repr},
3059 {"Amanda::Xferc::xfer_start", _wrap_xfer_start},
3060 {"Amanda::Xferc::xfer_cancel", _wrap_xfer_cancel},
3061 {"Amanda::Xferc::xfer_element_unref", _wrap_xfer_element_unref},
3062 {"Amanda::Xferc::xfer_element_repr", _wrap_xfer_element_repr},
3063 {"Amanda::Xferc::same_elements", _wrap_same_elements},
3064 {"Amanda::Xferc::xfer_source_random", _wrap_xfer_source_random},
3065 {"Amanda::Xferc::xfer_source_random_get_seed", _wrap_xfer_source_random_get_seed},
3066 {"Amanda::Xferc::xfer_source_pattern", _wrap_xfer_source_pattern},
3067 {"Amanda::Xferc::xfer_source_fd", _wrap_xfer_source_fd},
3068 {"Amanda::Xferc::xfer_source_directtcp_listen", _wrap_xfer_source_directtcp_listen},
3069 {"Amanda::Xferc::xfer_source_directtcp_listen_get_addrs", _wrap_xfer_source_directtcp_listen_get_addrs},
3070 {"Amanda::Xferc::xfer_source_directtcp_connect", _wrap_xfer_source_directtcp_connect},
3071 {"Amanda::Xferc::xfer_filter_xor", _wrap_xfer_filter_xor},
3072 {"Amanda::Xferc::xfer_filter_process", _wrap_xfer_filter_process},
3073 {"Amanda::Xferc::xfer_dest_null", _wrap_xfer_dest_null},
3074 {"Amanda::Xferc::xfer_dest_buffer", _wrap_xfer_dest_buffer},
3075 {"Amanda::Xferc::xfer_dest_buffer_get", _wrap_xfer_dest_buffer_get},
3076 {"Amanda::Xferc::xfer_dest_fd", _wrap_xfer_dest_fd},
3077 {"Amanda::Xferc::xfer_dest_directtcp_listen", _wrap_xfer_dest_directtcp_listen},
3078 {"Amanda::Xferc::xfer_dest_directtcp_listen_get_addrs", _wrap_xfer_dest_directtcp_listen_get_addrs},
3079 {"Amanda::Xferc::xfer_dest_directtcp_connect", _wrap_xfer_dest_directtcp_connect},
3080 {"Amanda::Xferc::xfer_get_amglue_source", _wrap_xfer_get_amglue_source},
3081 {0,0}
3082 };
3083 /* -----------------------------------------------------------------------------
3084  * Type initialization:
3085  * This problem is tough by the requirement that no dynamic
3086  * memory is used. Also, since swig_type_info structures store pointers to
3087  * swig_cast_info structures and swig_cast_info structures store pointers back
3088  * to swig_type_info structures, we need some lookup code at initialization.
3089  * The idea is that swig generates all the structures that are needed.
3090  * The runtime then collects these partially filled structures.
3091  * The SWIG_InitializeModule function takes these initial arrays out of
3092  * swig_module, and does all the lookup, filling in the swig_module.types
3093  * array with the correct data and linking the correct swig_cast_info
3094  * structures together.
3095  *
3096  * The generated swig_type_info structures are assigned staticly to an initial
3097  * array. We just loop through that array, and handle each type individually.
3098  * First we lookup if this type has been already loaded, and if so, use the
3099  * loaded structure instead of the generated one. Then we have to fill in the
3100  * cast linked list. The cast data is initially stored in something like a
3101  * two-dimensional array. Each row corresponds to a type (there are the same
3102  * number of rows as there are in the swig_type_initial array). Each entry in
3103  * a column is one of the swig_cast_info structures for that type.
3104  * The cast_initial array is actually an array of arrays, because each row has
3105  * a variable number of columns. So to actually build the cast linked list,
3106  * we find the array of casts associated with the type, and loop through it
3107  * adding the casts to the list. The one last trick we need to do is making
3108  * sure the type pointer in the swig_cast_info struct is correct.
3109  *
3110  * First off, we lookup the cast->type name to see if it is already loaded.
3111  * There are three cases to handle:
3112  *  1) If the cast->type has already been loaded AND the type we are adding
3113  *     casting info to has not been loaded (it is in this module), THEN we
3114  *     replace the cast->type pointer with the type pointer that has already
3115  *     been loaded.
3116  *  2) If BOTH types (the one we are adding casting info to, and the
3117  *     cast->type) are loaded, THEN the cast info has already been loaded by
3118  *     the previous module so we just ignore it.
3119  *  3) Finally, if cast->type has not already been loaded, then we add that
3120  *     swig_cast_info to the linked list (because the cast->type) pointer will
3121  *     be correct.
3122  * ----------------------------------------------------------------------------- */
3123
3124 #ifdef __cplusplus
3125 extern "C" {
3126 #if 0
3127 } /* c-mode */
3128 #endif
3129 #endif
3130
3131 #if 0
3132 #define SWIGRUNTIME_DEBUG
3133 #endif
3134
3135
3136 SWIGRUNTIME void
3137 SWIG_InitializeModule(void *clientdata) {
3138   size_t i;
3139   swig_module_info *module_head, *iter;
3140   int found, init;
3141
3142   clientdata = clientdata;
3143
3144   /* check to see if the circular list has been setup, if not, set it up */
3145   if (swig_module.next==0) {
3146     /* Initialize the swig_module */
3147     swig_module.type_initial = swig_type_initial;
3148     swig_module.cast_initial = swig_cast_initial;
3149     swig_module.next = &swig_module;
3150     init = 1;
3151   } else {
3152     init = 0;
3153   }
3154
3155   /* Try and load any already created modules */
3156   module_head = SWIG_GetModule(clientdata);
3157   if (!module_head) {
3158     /* This is the first module loaded for this interpreter */
3159     /* so set the swig module into the interpreter */
3160     SWIG_SetModule(clientdata, &swig_module);
3161     module_head = &swig_module;
3162   } else {
3163     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
3164     found=0;
3165     iter=module_head;
3166     do {
3167       if (iter==&swig_module) {
3168         found=1;
3169         break;
3170       }
3171       iter=iter->next;
3172     } while (iter!= module_head);
3173
3174     /* if the is found in the list, then all is done and we may leave */
3175     if (found) return;
3176     /* otherwise we must add out module into the list */
3177     swig_module.next = module_head->next;
3178     module_head->next = &swig_module;
3179   }
3180
3181   /* When multiple interpeters are used, a module could have already been initialized in
3182        a different interpreter, but not yet have a pointer in this interpreter.
3183        In this case, we do not want to continue adding types... everything should be
3184        set up already */
3185   if (init == 0) return;
3186
3187   /* Now work on filling in swig_module.types */
3188 #ifdef SWIGRUNTIME_DEBUG
3189   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
3190 #endif
3191   for (i = 0; i < swig_module.size; ++i) {
3192     swig_type_info *type = 0;
3193     swig_type_info *ret;
3194     swig_cast_info *cast;
3195
3196 #ifdef SWIGRUNTIME_DEBUG
3197     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3198 #endif
3199
3200     /* if there is another module already loaded */
3201     if (swig_module.next != &swig_module) {
3202       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3203     }
3204     if (type) {
3205       /* Overwrite clientdata field */
3206 #ifdef SWIGRUNTIME_DEBUG
3207       printf("SWIG_InitializeModule: found type %s\n", type->name);
3208 #endif
3209       if (swig_module.type_initial[i]->clientdata) {
3210         type->clientdata = swig_module.type_initial[i]->clientdata;
3211 #ifdef SWIGRUNTIME_DEBUG
3212         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3213 #endif
3214       }
3215     } else {
3216       type = swig_module.type_initial[i];
3217     }
3218
3219     /* Insert casting types */
3220     cast = swig_module.cast_initial[i];
3221     while (cast->type) {
3222       /* Don't need to add information already in the list */
3223       ret = 0;
3224 #ifdef SWIGRUNTIME_DEBUG
3225       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
3226 #endif
3227       if (swig_module.next != &swig_module) {
3228         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
3229 #ifdef SWIGRUNTIME_DEBUG
3230         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
3231 #endif
3232       }
3233       if (ret) {
3234         if (type == swig_module.type_initial[i]) {
3235 #ifdef SWIGRUNTIME_DEBUG
3236           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
3237 #endif
3238           cast->type = ret;
3239           ret = 0;
3240         } else {
3241           /* Check for casting already in the list */
3242           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
3243 #ifdef SWIGRUNTIME_DEBUG
3244           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
3245 #endif
3246           if (!ocast) ret = 0;
3247         }
3248       }
3249
3250       if (!ret) {
3251 #ifdef SWIGRUNTIME_DEBUG
3252         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
3253 #endif
3254         if (type->cast) {
3255           type->cast->prev = cast;
3256           cast->next = type->cast;
3257         }
3258         type->cast = cast;
3259       }
3260       cast++;
3261     }
3262     /* Set entry in modules->types array equal to the type */
3263     swig_module.types[i] = type;
3264   }
3265   swig_module.types[i] = 0;
3266
3267 #ifdef SWIGRUNTIME_DEBUG
3268   printf("**** SWIG_InitializeModule: Cast List ******\n");
3269   for (i = 0; i < swig_module.size; ++i) {
3270     int j = 0;
3271     swig_cast_info *cast = swig_module.cast_initial[i];
3272     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3273     while (cast->type) {
3274       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
3275       cast++;
3276       ++j;
3277     }
3278     printf("---- Total casts: %d\n",j);
3279   }
3280   printf("**** SWIG_InitializeModule: Cast List ******\n");
3281 #endif
3282 }
3283
3284 /* This function will propagate the clientdata field of type to
3285 * any new swig_type_info structures that have been added into the list
3286 * of equivalent types.  It is like calling
3287 * SWIG_TypeClientData(type, clientdata) a second time.
3288 */
3289 SWIGRUNTIME void
3290 SWIG_PropagateClientData(void) {
3291   size_t i;
3292   swig_cast_info *equiv;
3293   static int init_run = 0;
3294
3295   if (init_run) return;
3296   init_run = 1;
3297
3298   for (i = 0; i < swig_module.size; i++) {
3299     if (swig_module.types[i]->clientdata) {
3300       equiv = swig_module.types[i]->cast;
3301       while (equiv) {
3302         if (!equiv->converter) {
3303           if (equiv->type && !equiv->type->clientdata)
3304           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
3305         }
3306         equiv = equiv->next;
3307       }
3308     }
3309   }
3310 }
3311
3312 #ifdef __cplusplus
3313 #if 0
3314 {
3315   /* c-mode */
3316 #endif
3317 }
3318 #endif
3319
3320
3321
3322 #ifdef __cplusplus
3323 extern "C"
3324 #endif
3325
3326 XS(SWIG_init) {
3327   dXSARGS;
3328   int i;
3329
3330   SWIG_InitializeModule(0);
3331
3332   /* Install commands */
3333   for (i = 0; swig_commands[i].name; i++) {
3334     newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
3335   }
3336
3337   /* Install variables */
3338   for (i = 0; swig_variables[i].name; i++) {
3339     SV *sv;
3340     sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
3341     if (swig_variables[i].type) {
3342       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
3343     } else {
3344       sv_setiv(sv,(IV) 0);
3345     }
3346     swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
3347   }
3348
3349   /* Install constant */
3350   for (i = 0; swig_constants[i].type; i++) {
3351     SV *sv;
3352     sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
3353     switch(swig_constants[i].type) {
3354     case SWIG_INT:
3355       sv_setiv(sv, (IV) swig_constants[i].lvalue);
3356       break;
3357     case SWIG_FLOAT:
3358       sv_setnv(sv, (double) swig_constants[i].dvalue);
3359       break;
3360     case SWIG_STRING:
3361       sv_setpv(sv, (char *) swig_constants[i].pvalue);
3362       break;
3363     case SWIG_POINTER:
3364       SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
3365       break;
3366     case SWIG_BINARY:
3367       SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
3368       break;
3369     default:
3370       break;
3371     }
3372     SvREADONLY_on(sv);
3373   }
3374
3375
3376   /* We need GType and GThread initialized to use xfers */
3377   glib_init();
3378
3379   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3380     SV *sv = get_sv((char*) SWIG_prefix "XFER_INIT", TRUE | 0x2 | GV_ADDMULTI);
3381     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(XFER_INIT)));
3382     SvREADONLY_on(sv);
3383   } while(0) /*@SWIG@*/;
3384   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3385     SV *sv = get_sv((char*) SWIG_prefix "XFER_START", TRUE | 0x2 | GV_ADDMULTI);
3386     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(XFER_START)));
3387     SvREADONLY_on(sv);
3388   } while(0) /*@SWIG@*/;
3389   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3390     SV *sv = get_sv((char*) SWIG_prefix "XFER_RUNNING", TRUE | 0x2 | GV_ADDMULTI);
3391     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(XFER_RUNNING)));
3392     SvREADONLY_on(sv);
3393   } while(0) /*@SWIG@*/;
3394   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3395     SV *sv = get_sv((char*) SWIG_prefix "XFER_DONE", TRUE | 0x2 | GV_ADDMULTI);
3396     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(XFER_DONE)));
3397     SvREADONLY_on(sv);
3398   } while(0) /*@SWIG@*/;
3399   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3400     SV *sv = get_sv((char*) SWIG_prefix "XMSG_INFO", TRUE | 0x2 | GV_ADDMULTI);
3401     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(XMSG_INFO)));
3402     SvREADONLY_on(sv);
3403   } while(0) /*@SWIG@*/;
3404   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3405     SV *sv = get_sv((char*) SWIG_prefix "XMSG_ERROR", TRUE | 0x2 | GV_ADDMULTI);
3406     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(XMSG_ERROR)));
3407     SvREADONLY_on(sv);
3408   } while(0) /*@SWIG@*/;
3409   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3410     SV *sv = get_sv((char*) SWIG_prefix "XMSG_DONE", TRUE | 0x2 | GV_ADDMULTI);
3411     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(XMSG_DONE)));
3412     SvREADONLY_on(sv);
3413   } while(0) /*@SWIG@*/;
3414   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3415     SV *sv = get_sv((char*) SWIG_prefix "XMSG_CANCEL", TRUE | 0x2 | GV_ADDMULTI);
3416     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(XMSG_CANCEL)));
3417     SvREADONLY_on(sv);
3418   } while(0) /*@SWIG@*/;
3419   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3420     SV *sv = get_sv((char*) SWIG_prefix "XMSG_PART_DONE", TRUE | 0x2 | GV_ADDMULTI);
3421     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(XMSG_PART_DONE)));
3422     SvREADONLY_on(sv);
3423   } while(0) /*@SWIG@*/;
3424   /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3425     SV *sv = get_sv((char*) SWIG_prefix "XMSG_READY", TRUE | 0x2 | GV_ADDMULTI);
3426     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(XMSG_READY)));
3427     SvREADONLY_on(sv);
3428   } while(0) /*@SWIG@*/;
3429   ST(0) = &PL_sv_yes;
3430   XSRETURN(1);
3431 }
3432