Quvi_wrap.cxx

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