Quvi_wrap.cxx

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