Quvi_wrap.cxx

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 2.0.2
   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 #ifdef access
1658 #undef access
1659 #endif
1660 #ifdef stat
1661 #undef stat
1662 #endif
1663
1664
1665
1666 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1667
1668 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1669
1670
1671
1672 #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
1673
1674
1675 /* -------- TYPES TABLE (BEGIN) -------- */
1676
1677 #define SWIGTYPE_p_Link swig_types[0]
1678 #define SWIGTYPE_p_Options swig_types[1]
1679 #define SWIGTYPE_p_Query swig_types[2]
1680 #define SWIGTYPE_p_Video swig_types[3]
1681 #define SWIGTYPE_p_char swig_types[4]
1682 #define SWIGTYPE_p_quviCategory swig_types[5]
1683 #define SWIGTYPE_p_quviCode swig_types[6]
1684 #define SWIGTYPE_p_quviVersion swig_types[7]
1685 #define SWIGTYPE_p_std__string swig_types[8]
1686 static swig_type_info *swig_types[10];
1687 static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0};
1688 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1689 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1690
1691 /* -------- TYPES TABLE (END) -------- */
1692
1693 #define SWIG_init    boot_WWW__Quvi
1694
1695 #define SWIG_name   "WWW::Quvic::boot_WWW__Quvi"
1696 #define SWIG_prefix "WWW::Quvic::"
1697
1698 #define SWIGVERSION 0x020002
1699 #define SWIG_VERSION SWIGVERSION
1700
1701
1702 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
1703 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
1704
1705
1706 #include <stdexcept>
1707
1708
1709 #ifdef __cplusplus
1710 extern "C"
1711 #endif
1712 #ifndef PERL_OBJECT
1713 #ifndef MULTIPLICITY
1714 SWIGEXPORT void SWIG_init (CV* cv);
1715 #else
1716 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1717 #endif
1718 #else
1719 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1720 #endif
1721
1722
1723 #include <string>
1724
1725
1726 #include "Quvi.h"
1727
1728
1729
1730 char *_VERSION = VERSION;
1731
1732 typedef enum
1733 {
1734   libquviVersion      = QUVI_VERSION,
1735   libquviVersionLong  = QUVI_VERSION_LONG,
1736   ModuleVersion
1737 } quviVersion;
1738
1739 static char* version (quviVersion n=ModuleVersion)
1740 {
1741   if (n == ModuleVersion) return _VERSION;
1742   return quvi_version ((QUVIversion)n);
1743 }
1744
1745 /*
1746  * A manual copy of QUVIcode. If there's a better way to do this,
1747  * I'd like to know it too. This will need to be maintained manually
1748  * if there are any changes to the QUVIcode enum list in quvi.h file.
1749  *
1750  * The reason we don't simply "%include <quvi/quvi.h>" and
1751  * get the constants is because that would clutter the wrapper.
1752  *
1753  * We have renamed the constants to avoid any conflicts with those
1754  * defined in <quvi/quvi.h> which is included by the wrapper.
1755  */
1756 typedef enum
1757 {
1758   OK  = 0x00,
1759   Mem,
1760   BadHandle,
1761   InvArg,
1762   CurlInit,
1763   Last,
1764   AbortedByCallback,
1765   LuaInit,
1766   NoLuaWebsite,
1767   NoLuaUtil,
1768   PcreError= 0x40, /* QUVI_PCRE */
1769   NoSupport,
1770   CurlError,       /* QUVI_CURL */
1771   IconvError,      /* QUVI_ICONV */
1772   LuaError,        /* QUVI_LUA */
1773 } quviCode;
1774
1775 typedef enum
1776 {
1777   ProtoHttp = 0x1,
1778   ProtoMms  = 0x2,
1779   ProtoRtsp = 0x4,
1780   ProtoRtmp = 0x8,
1781   ProtoAll  = (ProtoHttp|ProtoMms|ProtoRtsp|ProtoRtmp)
1782 } quviCategory;
1783
1784
1785
1786 SWIGINTERN swig_type_info*
1787 SWIG_pchar_descriptor(void)
1788 {
1789   static int init = 0;
1790   static swig_type_info* info = 0;
1791   if (!init)
1792     {
1793       info = SWIG_TypeQuery("_p_char");
1794       init = 1;
1795     }
1796   return info;
1797 }
1798
1799
1800 SWIGINTERN int
1801 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1802 {
1803   if (SvMAGICAL(obj))
1804     {
1805       SV *tmp = sv_newmortal();
1806       SvSetSV(tmp, obj);
1807       obj = tmp;
1808     }
1809   if (SvPOK(obj))
1810     {
1811       STRLEN len = 0;
1812       char *cstr = SvPV(obj, len);
1813       size_t size = len + 1;
1814       if (cptr)
1815         {
1816           if (alloc)
1817             {
1818               if (*alloc == SWIG_NEWOBJ)
1819                 {
1820                   *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size)));
1821                 }
1822               else
1823                 {
1824                   *cptr = cstr;
1825                   *alloc = SWIG_OLDOBJ;
1826                 }
1827             }
1828         }
1829       if (psize) *psize = size;
1830       return SWIG_OK;
1831     }
1832   else
1833     {
1834       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1835       if (pchar_descriptor)
1836         {
1837           char* vptr = 0;
1838           if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK)
1839             {
1840               if (cptr) *cptr = vptr;
1841               if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1842               if (alloc) *alloc = SWIG_OLDOBJ;
1843               return SWIG_OK;
1844             }
1845         }
1846     }
1847   return SWIG_TypeError;
1848 }
1849
1850
1851 SWIGINTERNINLINE SV *
1852 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1853 {
1854   SV *obj = sv_newmortal();
1855   if (carray)
1856     {
1857       sv_setpvn(obj, carray, size);
1858     }
1859   else
1860     {
1861       sv_setsv(obj, &PL_sv_undef);
1862     }
1863   return obj;
1864 }
1865
1866
1867 SWIGINTERNINLINE SV *
1868 SWIG_FromCharPtr(const char *cptr)
1869 {
1870   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1871 }
1872
1873
1874 SWIGINTERNINLINE SV *
1875 SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
1876 {
1877   SV *obj = sv_newmortal();
1878   sv_setiv(obj, (IV) value);
1879   return obj;
1880 }
1881
1882
1883 SWIGINTERNINLINE SV *
1884 SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
1885 {
1886   return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
1887 }
1888
1889
1890 #include <limits.h>
1891 #if !defined(SWIG_NO_LLONG_MAX)
1892 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1893 #   define LLONG_MAX __LONG_LONG_MAX__
1894 #   define LLONG_MIN (-LLONG_MAX - 1LL)
1895 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1896 # endif
1897 #endif
1898
1899
1900 SWIGINTERN int
1901 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1902 {
1903   if (SvNIOK(obj))
1904     {
1905       if (val) *val = SvNV(obj);
1906       return SWIG_OK;
1907     }
1908   else if (SvIOK(obj))
1909     {
1910       if (val) *val = (double) SvIV(obj);
1911       return SWIG_AddCast(SWIG_OK);
1912     }
1913   else
1914     {
1915       const char *nptr = SvPV_nolen(obj);
1916       if (nptr)
1917         {
1918           char *endptr;
1919           double v;
1920           errno = 0;
1921           v = strtod(nptr, &endptr);
1922           if (errno == ERANGE)
1923             {
1924               errno = 0;
1925               return SWIG_OverflowError;
1926             }
1927           else
1928             {
1929               if (*endptr == '\0')
1930                 {
1931                   if (val) *val = v;
1932                   return SWIG_Str2NumCast(SWIG_OK);
1933                 }
1934             }
1935         }
1936     }
1937   return SWIG_TypeError;
1938 }
1939
1940
1941 #include <float.h>
1942
1943
1944 #include <math.h>
1945
1946
1947 SWIGINTERNINLINE int
1948 SWIG_CanCastAsInteger(double *d, double min, double max)
1949 {
1950   double x = *d;
1951   if ((min <= x && x <= max))
1952     {
1953       double fx = floor(x);
1954       double cx = ceil(x);
1955       double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1956       if ((errno == EDOM) || (errno == ERANGE))
1957         {
1958           errno = 0;
1959         }
1960       else
1961         {
1962           double summ, reps, diff;
1963           if (rd < x)
1964             {
1965               diff = x - rd;
1966             }
1967           else if (rd > x)
1968             {
1969               diff = rd - x;
1970             }
1971           else
1972             {
1973               return 1;
1974             }
1975           summ = rd + x;
1976           reps = diff/summ;
1977           if (reps < 8*DBL_EPSILON)
1978             {
1979               *d = rd;
1980               return 1;
1981             }
1982         }
1983     }
1984   return 0;
1985 }
1986
1987
1988 SWIGINTERN int
1989 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1990 {
1991   if (SvIOK(obj))
1992     {
1993       if (val) *val = SvIV(obj);
1994       return SWIG_OK;
1995     }
1996   else
1997     {
1998       int dispatch = 0;
1999       const char *nptr = SvPV_nolen(obj);
2000       if (nptr)
2001         {
2002           char *endptr;
2003           long v;
2004           errno = 0;
2005           v = strtol(nptr, &endptr,0);
2006           if (errno == ERANGE)
2007             {
2008               errno = 0;
2009               return SWIG_OverflowError;
2010             }
2011           else
2012             {
2013               if (*endptr == '\0')
2014                 {
2015                   if (val) *val = v;
2016                   return SWIG_Str2NumCast(SWIG_OK);
2017                 }
2018             }
2019         }
2020       if (!dispatch)
2021         {
2022           double d;
2023           int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
2024           if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX))
2025             {
2026               if (val) *val = (long)(d);
2027               return res;
2028             }
2029         }
2030     }
2031   return SWIG_TypeError;
2032 }
2033
2034
2035 SWIGINTERN int
2036 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
2037 {
2038   long v;
2039   int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
2040   if (SWIG_IsOK(res))
2041     {
2042       if ((v < INT_MIN || v > INT_MAX))
2043         {
2044           return SWIG_OverflowError;
2045         }
2046       else
2047         {
2048           if (val) *val = static_cast< int >(v);
2049         }
2050     }
2051   return res;
2052 }
2053
2054
2055 SWIGINTERN int
2056 SWIG_AsPtr_std_string SWIG_PERL_DECL_ARGS_2(SV * obj, std::string **val)
2057 {
2058   char* buf = 0 ;
2059   size_t size = 0;
2060   int alloc = SWIG_OLDOBJ;
2061   if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc))))
2062     {
2063       if (buf)
2064         {
2065           if (val) *val = new std::string(buf, size - 1);
2066           if (alloc == SWIG_NEWOBJ) delete[] buf;
2067           return SWIG_NEWOBJ;
2068         }
2069       else
2070         {
2071           if (val) *val = 0;
2072           return SWIG_OLDOBJ;
2073         }
2074     }
2075   else
2076     {
2077       static int init = 0;
2078       static swig_type_info* descriptor = 0;
2079       if (!init)
2080         {
2081           descriptor = SWIG_TypeQuery("std::string" " *");
2082           init = 1;
2083         }
2084       if (descriptor)
2085         {
2086           std::string *vptr;
2087           int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
2088           if (SWIG_IsOK(res) && val) *val = vptr;
2089           return res;
2090         }
2091     }
2092   return SWIG_ERROR;
2093 }
2094
2095
2096 SWIGINTERNINLINE SV *
2097 SWIG_From_std_string  SWIG_PERL_DECL_ARGS_1(const std::string& s)
2098 {
2099   return SWIG_FromCharPtrAndSize(s.data(), s.size());
2100 }
2101
2102
2103 SWIGINTERN int
2104 SWIG_AsVal_bool SWIG_PERL_DECL_ARGS_2(SV *obj, bool* val)
2105 {
2106   if (obj == &PL_sv_yes)
2107     {
2108       if (val) *val = true;
2109       return SWIG_OK;
2110     }
2111   else if (obj == &PL_sv_no)
2112     {
2113       if (val) *val = false;
2114       return SWIG_OK;
2115     }
2116   else
2117     {
2118       if (val) *val = SvTRUE(obj) ? true: false;
2119       return SWIG_AddCast(SWIG_OK);
2120     }
2121   return SWIG_TypeError;
2122 }
2123
2124
2125 SWIGINTERNINLINE SV *
2126 SWIG_From_bool  SWIG_PERL_DECL_ARGS_1(bool value)
2127 {
2128   SV *obj = sv_newmortal();
2129   if (value)
2130     {
2131       sv_setsv(obj, &PL_sv_yes);
2132     }
2133   else
2134     {
2135       sv_setsv(obj, &PL_sv_no);
2136     }
2137   return obj;
2138 }
2139
2140
2141 SWIGINTERNINLINE SV *
2142 SWIG_From_double  SWIG_PERL_DECL_ARGS_1(double value)
2143 {
2144   SV *obj = sv_newmortal();
2145   sv_setnv(obj, value);
2146   return obj;
2147 }
2148
2149 #ifdef __cplusplus
2150 extern "C" {
2151 #endif
2152
2153 #ifdef PERL_OBJECT
2154 #define MAGIC_CLASS _wrap_WWW__Quvi_var::
2155   class _wrap_WWW__Quvi_var : public CPerlObj
2156   {
2157   public:
2158 #else
2159 #define MAGIC_CLASS
2160 #endif
2161     SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg))
2162     {
2163       MAGIC_PPERL
2164       croak("Value is read-only.");
2165       return 0;
2166     }
2167     SWIGCLASS_STATIC int _wrap__VERSION_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg))
2168     {
2169       MAGIC_PPERL
2170       {
2171         char *cptr = 0;
2172         size_t csize = 0;
2173         int alloc = SWIG_NEWOBJ;
2174         int res = SWIG_AsCharPtrAndSize(sv, &cptr, &csize, &alloc);
2175         if (!SWIG_IsOK(res))
2176           {
2177             SWIG_exception_fail(SWIG_ArgError(res), "in variable '""_VERSION""' of type '""char *""'");
2178           }
2179         if (_VERSION) delete[] _VERSION;
2180         if (alloc == SWIG_NEWOBJ)
2181           {
2182             _VERSION = cptr;
2183           }
2184         else {
2185             _VERSION = csize ? (char *)reinterpret_cast< char* >(memcpy((new char[csize]), cptr, sizeof(char)*(csize))) : 0;
2186           }
2187       }
2188 fail:
2189       return 1;
2190     }
2191
2192
2193     SWIGCLASS_STATIC int _wrap__VERSION_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg))
2194     {
2195       MAGIC_PPERL
2196       sv_setsv(sv,SWIG_FromCharPtr(_VERSION))  ;
2197       return 1;
2198     }
2199
2200
2201
2202
2203 #ifdef PERL_OBJECT
2204   };
2205 #endif
2206
2207 #ifdef __cplusplus
2208 }
2209 #endif
2210
2211 #ifdef __cplusplus
2212 extern "C" {
2213 #endif
2214   XS(_wrap_version__SWIG_0)
2215   {
2216     {
2217       quviVersion arg1 ;
2218       int val1 ;
2219       int ecode1 = 0 ;
2220       int argvi = 0;
2221       char *result = 0 ;
2222       dXSARGS;
2223
2224       if ((items < 1) || (items > 1))
2225         {
2226           SWIG_croak("Usage: version(n);");
2227         }
2228       ecode1 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2229       if (!SWIG_IsOK(ecode1))
2230         {
2231           SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "version" "', argument " "1"" of type '" "quviVersion""'");
2232         }
2233       arg1 = static_cast< quviVersion >(val1);
2234       result = (char *)version(arg1);
2235       ST(argvi) = SWIG_FromCharPtr((const char *)result);
2236       argvi++ ;
2237
2238       XSRETURN(argvi);
2239 fail:
2240
2241       SWIG_croak_null();
2242     }
2243   }
2244
2245
2246   XS(_wrap_version__SWIG_1)
2247   {
2248     {
2249       int argvi = 0;
2250       char *result = 0 ;
2251       dXSARGS;
2252
2253       if ((items < 0) || (items > 0))
2254         {
2255           SWIG_croak("Usage: version();");
2256         }
2257       result = (char *)version();
2258       ST(argvi) = SWIG_FromCharPtr((const char *)result);
2259       argvi++ ;
2260       XSRETURN(argvi);
2261 fail:
2262       SWIG_croak_null();
2263     }
2264   }
2265
2266
2267   XS(_wrap_version)
2268   {
2269     dXSARGS;
2270
2271     {
2272       unsigned long _index = 0;
2273       SWIG_TypeRank _rank = 0;
2274       if (items == 0)
2275         {
2276           SWIG_TypeRank _ranki = 0;
2277           SWIG_TypeRank _rankm = 0;
2278           if (!_index || (_ranki < _rank))
2279             {
2280               _rank = _ranki;
2281               _index = 1;
2282               if (_rank == _rankm) goto dispatch;
2283             }
2284         }
2285       if (items == 1)
2286         {
2287           SWIG_TypeRank _ranki = 0;
2288           SWIG_TypeRank _rankm = 0;
2289           SWIG_TypeRank _pi = 1;
2290           int _v = 0;
2291           {
2292             {
2293               int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(0), NULL);
2294               _v = SWIG_CheckState(res);
2295             }
2296           }
2297           if (!_v) goto check_2;
2298           _ranki += _v*_pi;
2299           _rankm += _pi;
2300           _pi *= SWIG_MAXCASTRANK;
2301           if (!_index || (_ranki < _rank))
2302             {
2303               _rank = _ranki;
2304               _index = 2;
2305               if (_rank == _rankm) goto dispatch;
2306             }
2307         }
2308 check_2:
2309
2310 dispatch:
2311       switch(_index)
2312         {
2313         case 1:
2314           ++PL_markstack_ptr;
2315           SWIG_CALLXS(_wrap_version__SWIG_1);
2316           return;
2317         case 2:
2318           ++PL_markstack_ptr;
2319           SWIG_CALLXS(_wrap_version__SWIG_0);
2320           return;
2321         }
2322     }
2323
2324     croak("No matching function for overloaded 'version'");
2325     XSRETURN(0);
2326   }
2327
2328
2329   XS(_wrap_new_Options)
2330   {
2331     {
2332       int argvi = 0;
2333       Options *result = 0 ;
2334       dXSARGS;
2335
2336       if ((items < 0) || (items > 0))
2337         {
2338           SWIG_croak("Usage: new_Options();");
2339         }
2340       result = (Options *)new Options();
2341       ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Options, SWIG_OWNER | SWIG_SHADOW);
2342       argvi++ ;
2343       XSRETURN(argvi);
2344 fail:
2345       SWIG_croak_null();
2346     }
2347   }
2348
2349
2350   XS(_wrap_Options_user_agent_set)
2351   {
2352     {
2353       Options *arg1 = (Options *) 0 ;
2354       std::string *arg2 = 0 ;
2355       void *argp1 = 0 ;
2356       int res1 = 0 ;
2357       int res2 = SWIG_OLDOBJ ;
2358       int argvi = 0;
2359       dXSARGS;
2360
2361       if ((items < 2) || (items > 2))
2362         {
2363           SWIG_croak("Usage: Options_user_agent_set(self,user_agent);");
2364         }
2365       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2366       if (!SWIG_IsOK(res1))
2367         {
2368           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_user_agent_set" "', argument " "1"" of type '" "Options *""'");
2369         }
2370       arg1 = reinterpret_cast< Options * >(argp1);
2371       {
2372         std::string *ptr = (std::string *)0;
2373         res2 = SWIG_AsPtr_std_string SWIG_PERL_CALL_ARGS_2(ST(1), &ptr);
2374         if (!SWIG_IsOK(res2))
2375           {
2376             SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Options_user_agent_set" "', argument " "2"" of type '" "std::string const &""'");
2377           }
2378         if (!ptr)
2379           {
2380             SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Options_user_agent_set" "', argument " "2"" of type '" "std::string const &""'");
2381           }
2382         arg2 = ptr;
2383       }
2384       if (arg1) (arg1)->user_agent = *arg2;
2385       ST(argvi) = sv_newmortal();
2386
2387       if (SWIG_IsNewObj(res2)) delete arg2;
2388       XSRETURN(argvi);
2389 fail:
2390
2391       if (SWIG_IsNewObj(res2)) delete arg2;
2392       SWIG_croak_null();
2393     }
2394   }
2395
2396
2397   XS(_wrap_Options_user_agent_get)
2398   {
2399     {
2400       Options *arg1 = (Options *) 0 ;
2401       void *argp1 = 0 ;
2402       int res1 = 0 ;
2403       int argvi = 0;
2404       std::string *result = 0 ;
2405       dXSARGS;
2406
2407       if ((items < 1) || (items > 1))
2408         {
2409           SWIG_croak("Usage: Options_user_agent_get(self);");
2410         }
2411       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2412       if (!SWIG_IsOK(res1))
2413         {
2414           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_user_agent_get" "', argument " "1"" of type '" "Options *""'");
2415         }
2416       arg1 = reinterpret_cast< Options * >(argp1);
2417       result = (std::string *) & ((arg1)->user_agent);
2418       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
2419       argvi++ ;
2420
2421       XSRETURN(argvi);
2422 fail:
2423
2424       SWIG_croak_null();
2425     }
2426   }
2427
2428
2429   XS(_wrap_Options_http_proxy_set)
2430   {
2431     {
2432       Options *arg1 = (Options *) 0 ;
2433       std::string *arg2 = 0 ;
2434       void *argp1 = 0 ;
2435       int res1 = 0 ;
2436       int res2 = SWIG_OLDOBJ ;
2437       int argvi = 0;
2438       dXSARGS;
2439
2440       if ((items < 2) || (items > 2))
2441         {
2442           SWIG_croak("Usage: Options_http_proxy_set(self,http_proxy);");
2443         }
2444       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2445       if (!SWIG_IsOK(res1))
2446         {
2447           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_http_proxy_set" "', argument " "1"" of type '" "Options *""'");
2448         }
2449       arg1 = reinterpret_cast< Options * >(argp1);
2450       {
2451         std::string *ptr = (std::string *)0;
2452         res2 = SWIG_AsPtr_std_string SWIG_PERL_CALL_ARGS_2(ST(1), &ptr);
2453         if (!SWIG_IsOK(res2))
2454           {
2455             SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Options_http_proxy_set" "', argument " "2"" of type '" "std::string const &""'");
2456           }
2457         if (!ptr)
2458           {
2459             SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Options_http_proxy_set" "', argument " "2"" of type '" "std::string const &""'");
2460           }
2461         arg2 = ptr;
2462       }
2463       if (arg1) (arg1)->http_proxy = *arg2;
2464       ST(argvi) = sv_newmortal();
2465
2466       if (SWIG_IsNewObj(res2)) delete arg2;
2467       XSRETURN(argvi);
2468 fail:
2469
2470       if (SWIG_IsNewObj(res2)) delete arg2;
2471       SWIG_croak_null();
2472     }
2473   }
2474
2475
2476   XS(_wrap_Options_http_proxy_get)
2477   {
2478     {
2479       Options *arg1 = (Options *) 0 ;
2480       void *argp1 = 0 ;
2481       int res1 = 0 ;
2482       int argvi = 0;
2483       std::string *result = 0 ;
2484       dXSARGS;
2485
2486       if ((items < 1) || (items > 1))
2487         {
2488           SWIG_croak("Usage: Options_http_proxy_get(self);");
2489         }
2490       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2491       if (!SWIG_IsOK(res1))
2492         {
2493           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_http_proxy_get" "', argument " "1"" of type '" "Options *""'");
2494         }
2495       arg1 = reinterpret_cast< Options * >(argp1);
2496       result = (std::string *) & ((arg1)->http_proxy);
2497       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
2498       argvi++ ;
2499
2500       XSRETURN(argvi);
2501 fail:
2502
2503       SWIG_croak_null();
2504     }
2505   }
2506
2507
2508   XS(_wrap_Options_verbose_libcurl_set)
2509   {
2510     {
2511       Options *arg1 = (Options *) 0 ;
2512       bool arg2 ;
2513       void *argp1 = 0 ;
2514       int res1 = 0 ;
2515       bool val2 ;
2516       int ecode2 = 0 ;
2517       int argvi = 0;
2518       dXSARGS;
2519
2520       if ((items < 2) || (items > 2))
2521         {
2522           SWIG_croak("Usage: Options_verbose_libcurl_set(self,verbose_libcurl);");
2523         }
2524       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2525       if (!SWIG_IsOK(res1))
2526         {
2527           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_verbose_libcurl_set" "', argument " "1"" of type '" "Options *""'");
2528         }
2529       arg1 = reinterpret_cast< Options * >(argp1);
2530       ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2531       if (!SWIG_IsOK(ecode2))
2532         {
2533           SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Options_verbose_libcurl_set" "', argument " "2"" of type '" "bool""'");
2534         }
2535       arg2 = static_cast< bool >(val2);
2536       if (arg1) (arg1)->verbose_libcurl = arg2;
2537       ST(argvi) = sv_newmortal();
2538
2539
2540       XSRETURN(argvi);
2541 fail:
2542
2543
2544       SWIG_croak_null();
2545     }
2546   }
2547
2548
2549   XS(_wrap_Options_verbose_libcurl_get)
2550   {
2551     {
2552       Options *arg1 = (Options *) 0 ;
2553       void *argp1 = 0 ;
2554       int res1 = 0 ;
2555       int argvi = 0;
2556       bool result;
2557       dXSARGS;
2558
2559       if ((items < 1) || (items > 1))
2560         {
2561           SWIG_croak("Usage: Options_verbose_libcurl_get(self);");
2562         }
2563       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2564       if (!SWIG_IsOK(res1))
2565         {
2566           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_verbose_libcurl_get" "', argument " "1"" of type '" "Options *""'");
2567         }
2568       arg1 = reinterpret_cast< Options * >(argp1);
2569       result = (bool) ((arg1)->verbose_libcurl);
2570       ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result));
2571       argvi++ ;
2572
2573       XSRETURN(argvi);
2574 fail:
2575
2576       SWIG_croak_null();
2577     }
2578   }
2579
2580
2581   XS(_wrap_Options_format_set)
2582   {
2583     {
2584       Options *arg1 = (Options *) 0 ;
2585       std::string *arg2 = 0 ;
2586       void *argp1 = 0 ;
2587       int res1 = 0 ;
2588       int res2 = SWIG_OLDOBJ ;
2589       int argvi = 0;
2590       dXSARGS;
2591
2592       if ((items < 2) || (items > 2))
2593         {
2594           SWIG_croak("Usage: Options_format_set(self,format);");
2595         }
2596       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2597       if (!SWIG_IsOK(res1))
2598         {
2599           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_format_set" "', argument " "1"" of type '" "Options *""'");
2600         }
2601       arg1 = reinterpret_cast< Options * >(argp1);
2602       {
2603         std::string *ptr = (std::string *)0;
2604         res2 = SWIG_AsPtr_std_string SWIG_PERL_CALL_ARGS_2(ST(1), &ptr);
2605         if (!SWIG_IsOK(res2))
2606           {
2607             SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Options_format_set" "', argument " "2"" of type '" "std::string const &""'");
2608           }
2609         if (!ptr)
2610           {
2611             SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Options_format_set" "', argument " "2"" of type '" "std::string const &""'");
2612           }
2613         arg2 = ptr;
2614       }
2615       if (arg1) (arg1)->format = *arg2;
2616       ST(argvi) = sv_newmortal();
2617
2618       if (SWIG_IsNewObj(res2)) delete arg2;
2619       XSRETURN(argvi);
2620 fail:
2621
2622       if (SWIG_IsNewObj(res2)) delete arg2;
2623       SWIG_croak_null();
2624     }
2625   }
2626
2627
2628   XS(_wrap_Options_format_get)
2629   {
2630     {
2631       Options *arg1 = (Options *) 0 ;
2632       void *argp1 = 0 ;
2633       int res1 = 0 ;
2634       int argvi = 0;
2635       std::string *result = 0 ;
2636       dXSARGS;
2637
2638       if ((items < 1) || (items > 1))
2639         {
2640           SWIG_croak("Usage: Options_format_get(self);");
2641         }
2642       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2643       if (!SWIG_IsOK(res1))
2644         {
2645           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_format_get" "', argument " "1"" of type '" "Options *""'");
2646         }
2647       arg1 = reinterpret_cast< Options * >(argp1);
2648       result = (std::string *) & ((arg1)->format);
2649       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
2650       argvi++ ;
2651
2652       XSRETURN(argvi);
2653 fail:
2654
2655       SWIG_croak_null();
2656     }
2657   }
2658
2659
2660   XS(_wrap_Options_verify_set)
2661   {
2662     {
2663       Options *arg1 = (Options *) 0 ;
2664       bool arg2 ;
2665       void *argp1 = 0 ;
2666       int res1 = 0 ;
2667       bool val2 ;
2668       int ecode2 = 0 ;
2669       int argvi = 0;
2670       dXSARGS;
2671
2672       if ((items < 2) || (items > 2))
2673         {
2674           SWIG_croak("Usage: Options_verify_set(self,verify);");
2675         }
2676       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2677       if (!SWIG_IsOK(res1))
2678         {
2679           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_verify_set" "', argument " "1"" of type '" "Options *""'");
2680         }
2681       arg1 = reinterpret_cast< Options * >(argp1);
2682       ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2683       if (!SWIG_IsOK(ecode2))
2684         {
2685           SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Options_verify_set" "', argument " "2"" of type '" "bool""'");
2686         }
2687       arg2 = static_cast< bool >(val2);
2688       if (arg1) (arg1)->verify = arg2;
2689       ST(argvi) = sv_newmortal();
2690
2691
2692       XSRETURN(argvi);
2693 fail:
2694
2695
2696       SWIG_croak_null();
2697     }
2698   }
2699
2700
2701   XS(_wrap_Options_verify_get)
2702   {
2703     {
2704       Options *arg1 = (Options *) 0 ;
2705       void *argp1 = 0 ;
2706       int res1 = 0 ;
2707       int argvi = 0;
2708       bool result;
2709       dXSARGS;
2710
2711       if ((items < 1) || (items > 1))
2712         {
2713           SWIG_croak("Usage: Options_verify_get(self);");
2714         }
2715       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2716       if (!SWIG_IsOK(res1))
2717         {
2718           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_verify_get" "', argument " "1"" of type '" "Options *""'");
2719         }
2720       arg1 = reinterpret_cast< Options * >(argp1);
2721       result = (bool) ((arg1)->verify);
2722       ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result));
2723       argvi++ ;
2724
2725       XSRETURN(argvi);
2726 fail:
2727
2728       SWIG_croak_null();
2729     }
2730   }
2731
2732
2733   XS(_wrap_Options_shortened_set)
2734   {
2735     {
2736       Options *arg1 = (Options *) 0 ;
2737       bool arg2 ;
2738       void *argp1 = 0 ;
2739       int res1 = 0 ;
2740       bool val2 ;
2741       int ecode2 = 0 ;
2742       int argvi = 0;
2743       dXSARGS;
2744
2745       if ((items < 2) || (items > 2))
2746         {
2747           SWIG_croak("Usage: Options_shortened_set(self,shortened);");
2748         }
2749       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2750       if (!SWIG_IsOK(res1))
2751         {
2752           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_shortened_set" "', argument " "1"" of type '" "Options *""'");
2753         }
2754       arg1 = reinterpret_cast< Options * >(argp1);
2755       ecode2 = SWIG_AsVal_bool SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2756       if (!SWIG_IsOK(ecode2))
2757         {
2758           SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Options_shortened_set" "', argument " "2"" of type '" "bool""'");
2759         }
2760       arg2 = static_cast< bool >(val2);
2761       if (arg1) (arg1)->shortened = arg2;
2762       ST(argvi) = sv_newmortal();
2763
2764
2765       XSRETURN(argvi);
2766 fail:
2767
2768
2769       SWIG_croak_null();
2770     }
2771   }
2772
2773
2774   XS(_wrap_Options_shortened_get)
2775   {
2776     {
2777       Options *arg1 = (Options *) 0 ;
2778       void *argp1 = 0 ;
2779       int res1 = 0 ;
2780       int argvi = 0;
2781       bool result;
2782       dXSARGS;
2783
2784       if ((items < 1) || (items > 1))
2785         {
2786           SWIG_croak("Usage: Options_shortened_get(self);");
2787         }
2788       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2789       if (!SWIG_IsOK(res1))
2790         {
2791           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_shortened_get" "', argument " "1"" of type '" "Options *""'");
2792         }
2793       arg1 = reinterpret_cast< Options * >(argp1);
2794       result = (bool) ((arg1)->shortened);
2795       ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result));
2796       argvi++ ;
2797
2798       XSRETURN(argvi);
2799 fail:
2800
2801       SWIG_croak_null();
2802     }
2803   }
2804
2805
2806   XS(_wrap_Options_category_set)
2807   {
2808     {
2809       Options *arg1 = (Options *) 0 ;
2810       long arg2 ;
2811       void *argp1 = 0 ;
2812       int res1 = 0 ;
2813       long val2 ;
2814       int ecode2 = 0 ;
2815       int argvi = 0;
2816       dXSARGS;
2817
2818       if ((items < 2) || (items > 2))
2819         {
2820           SWIG_croak("Usage: Options_category_set(self,category);");
2821         }
2822       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2823       if (!SWIG_IsOK(res1))
2824         {
2825           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_category_set" "', argument " "1"" of type '" "Options *""'");
2826         }
2827       arg1 = reinterpret_cast< Options * >(argp1);
2828       ecode2 = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
2829       if (!SWIG_IsOK(ecode2))
2830         {
2831           SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Options_category_set" "', argument " "2"" of type '" "long""'");
2832         }
2833       arg2 = static_cast< long >(val2);
2834       if (arg1) (arg1)->category = arg2;
2835       ST(argvi) = sv_newmortal();
2836
2837
2838       XSRETURN(argvi);
2839 fail:
2840
2841
2842       SWIG_croak_null();
2843     }
2844   }
2845
2846
2847   XS(_wrap_Options_category_get)
2848   {
2849     {
2850       Options *arg1 = (Options *) 0 ;
2851       void *argp1 = 0 ;
2852       int res1 = 0 ;
2853       int argvi = 0;
2854       long result;
2855       dXSARGS;
2856
2857       if ((items < 1) || (items > 1))
2858         {
2859           SWIG_croak("Usage: Options_category_get(self);");
2860         }
2861       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, 0 |  0 );
2862       if (!SWIG_IsOK(res1))
2863         {
2864           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Options_category_get" "', argument " "1"" of type '" "Options *""'");
2865         }
2866       arg1 = reinterpret_cast< Options * >(argp1);
2867       result = (long) ((arg1)->category);
2868       ST(argvi) = SWIG_From_long  SWIG_PERL_CALL_ARGS_1(static_cast< long >(result));
2869       argvi++ ;
2870
2871       XSRETURN(argvi);
2872 fail:
2873
2874       SWIG_croak_null();
2875     }
2876   }
2877
2878
2879   XS(_wrap_delete_Options)
2880   {
2881     {
2882       Options *arg1 = (Options *) 0 ;
2883       void *argp1 = 0 ;
2884       int res1 = 0 ;
2885       int argvi = 0;
2886       dXSARGS;
2887
2888       if ((items < 1) || (items > 1))
2889         {
2890           SWIG_croak("Usage: delete_Options(self);");
2891         }
2892       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Options, SWIG_POINTER_DISOWN |  0 );
2893       if (!SWIG_IsOK(res1))
2894         {
2895           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Options" "', argument " "1"" of type '" "Options *""'");
2896         }
2897       arg1 = reinterpret_cast< Options * >(argp1);
2898       delete arg1;
2899       ST(argvi) = sv_newmortal();
2900
2901       XSRETURN(argvi);
2902 fail:
2903
2904       SWIG_croak_null();
2905     }
2906   }
2907
2908
2909   XS(_wrap_new_Link)
2910   {
2911     {
2912       int argvi = 0;
2913       Link *result = 0 ;
2914       dXSARGS;
2915
2916       if ((items < 0) || (items > 0))
2917         {
2918           SWIG_croak("Usage: new_Link();");
2919         }
2920       result = (Link *)new Link();
2921       ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Link, SWIG_OWNER | SWIG_SHADOW);
2922       argvi++ ;
2923       XSRETURN(argvi);
2924 fail:
2925       SWIG_croak_null();
2926     }
2927   }
2928
2929
2930   XS(_wrap_Link_content_type_get)
2931   {
2932     {
2933       Link *arg1 = (Link *) 0 ;
2934       void *argp1 = 0 ;
2935       int res1 = 0 ;
2936       int argvi = 0;
2937       std::string *result = 0 ;
2938       dXSARGS;
2939
2940       if ((items < 1) || (items > 1))
2941         {
2942           SWIG_croak("Usage: Link_content_type_get(self);");
2943         }
2944       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Link, 0 |  0 );
2945       if (!SWIG_IsOK(res1))
2946         {
2947           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Link_content_type_get" "', argument " "1"" of type '" "Link *""'");
2948         }
2949       arg1 = reinterpret_cast< Link * >(argp1);
2950       result = (std::string *) & ((arg1)->content_type);
2951       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
2952       argvi++ ;
2953
2954       XSRETURN(argvi);
2955 fail:
2956
2957       SWIG_croak_null();
2958     }
2959   }
2960
2961
2962   XS(_wrap_Link_file_suffix_get)
2963   {
2964     {
2965       Link *arg1 = (Link *) 0 ;
2966       void *argp1 = 0 ;
2967       int res1 = 0 ;
2968       int argvi = 0;
2969       std::string *result = 0 ;
2970       dXSARGS;
2971
2972       if ((items < 1) || (items > 1))
2973         {
2974           SWIG_croak("Usage: Link_file_suffix_get(self);");
2975         }
2976       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Link, 0 |  0 );
2977       if (!SWIG_IsOK(res1))
2978         {
2979           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Link_file_suffix_get" "', argument " "1"" of type '" "Link *""'");
2980         }
2981       arg1 = reinterpret_cast< Link * >(argp1);
2982       result = (std::string *) & ((arg1)->file_suffix);
2983       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
2984       argvi++ ;
2985
2986       XSRETURN(argvi);
2987 fail:
2988
2989       SWIG_croak_null();
2990     }
2991   }
2992
2993
2994   XS(_wrap_Link_length_bytes_get)
2995   {
2996     {
2997       Link *arg1 = (Link *) 0 ;
2998       void *argp1 = 0 ;
2999       int res1 = 0 ;
3000       int argvi = 0;
3001       double result;
3002       dXSARGS;
3003
3004       if ((items < 1) || (items > 1))
3005         {
3006           SWIG_croak("Usage: Link_length_bytes_get(self);");
3007         }
3008       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Link, 0 |  0 );
3009       if (!SWIG_IsOK(res1))
3010         {
3011           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Link_length_bytes_get" "', argument " "1"" of type '" "Link *""'");
3012         }
3013       arg1 = reinterpret_cast< Link * >(argp1);
3014       result = (double) ((arg1)->length_bytes);
3015       ST(argvi) = SWIG_From_double  SWIG_PERL_CALL_ARGS_1(static_cast< double >(result));
3016       argvi++ ;
3017
3018       XSRETURN(argvi);
3019 fail:
3020
3021       SWIG_croak_null();
3022     }
3023   }
3024
3025
3026   XS(_wrap_Link_url_get)
3027   {
3028     {
3029       Link *arg1 = (Link *) 0 ;
3030       void *argp1 = 0 ;
3031       int res1 = 0 ;
3032       int argvi = 0;
3033       std::string *result = 0 ;
3034       dXSARGS;
3035
3036       if ((items < 1) || (items > 1))
3037         {
3038           SWIG_croak("Usage: Link_url_get(self);");
3039         }
3040       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Link, 0 |  0 );
3041       if (!SWIG_IsOK(res1))
3042         {
3043           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Link_url_get" "', argument " "1"" of type '" "Link *""'");
3044         }
3045       arg1 = reinterpret_cast< Link * >(argp1);
3046       result = (std::string *) & ((arg1)->url);
3047       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
3048       argvi++ ;
3049
3050       XSRETURN(argvi);
3051 fail:
3052
3053       SWIG_croak_null();
3054     }
3055   }
3056
3057
3058   XS(_wrap_delete_Link)
3059   {
3060     {
3061       Link *arg1 = (Link *) 0 ;
3062       void *argp1 = 0 ;
3063       int res1 = 0 ;
3064       int argvi = 0;
3065       dXSARGS;
3066
3067       if ((items < 1) || (items > 1))
3068         {
3069           SWIG_croak("Usage: delete_Link(self);");
3070         }
3071       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Link, SWIG_POINTER_DISOWN |  0 );
3072       if (!SWIG_IsOK(res1))
3073         {
3074           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Link" "', argument " "1"" of type '" "Link *""'");
3075         }
3076       arg1 = reinterpret_cast< Link * >(argp1);
3077       delete arg1;
3078       ST(argvi) = sv_newmortal();
3079
3080       XSRETURN(argvi);
3081 fail:
3082
3083       SWIG_croak_null();
3084     }
3085   }
3086
3087
3088   XS(_wrap_new_Video)
3089   {
3090     {
3091       int argvi = 0;
3092       Video *result = 0 ;
3093       dXSARGS;
3094
3095       if ((items < 0) || (items > 0))
3096         {
3097           SWIG_croak("Usage: new_Video();");
3098         }
3099       result = (Video *)new Video();
3100       ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Video, SWIG_OWNER | SWIG_SHADOW);
3101       argvi++ ;
3102       XSRETURN(argvi);
3103 fail:
3104       SWIG_croak_null();
3105     }
3106   }
3107
3108
3109   XS(_wrap_Video_title_get)
3110   {
3111     {
3112       Video *arg1 = (Video *) 0 ;
3113       void *argp1 = 0 ;
3114       int res1 = 0 ;
3115       int argvi = 0;
3116       std::string *result = 0 ;
3117       dXSARGS;
3118
3119       if ((items < 1) || (items > 1))
3120         {
3121           SWIG_croak("Usage: Video_title_get(self);");
3122         }
3123       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Video, 0 |  0 );
3124       if (!SWIG_IsOK(res1))
3125         {
3126           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Video_title_get" "', argument " "1"" of type '" "Video *""'");
3127         }
3128       arg1 = reinterpret_cast< Video * >(argp1);
3129       result = (std::string *) & ((arg1)->title);
3130       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
3131       argvi++ ;
3132
3133       XSRETURN(argvi);
3134 fail:
3135
3136       SWIG_croak_null();
3137     }
3138   }
3139
3140
3141   XS(_wrap_Video_host_get)
3142   {
3143     {
3144       Video *arg1 = (Video *) 0 ;
3145       void *argp1 = 0 ;
3146       int res1 = 0 ;
3147       int argvi = 0;
3148       std::string *result = 0 ;
3149       dXSARGS;
3150
3151       if ((items < 1) || (items > 1))
3152         {
3153           SWIG_croak("Usage: Video_host_get(self);");
3154         }
3155       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Video, 0 |  0 );
3156       if (!SWIG_IsOK(res1))
3157         {
3158           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Video_host_get" "', argument " "1"" of type '" "Video *""'");
3159         }
3160       arg1 = reinterpret_cast< Video * >(argp1);
3161       result = (std::string *) & ((arg1)->host);
3162       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
3163       argvi++ ;
3164
3165       XSRETURN(argvi);
3166 fail:
3167
3168       SWIG_croak_null();
3169     }
3170   }
3171
3172
3173   XS(_wrap_Video_url_get)
3174   {
3175     {
3176       Video *arg1 = (Video *) 0 ;
3177       void *argp1 = 0 ;
3178       int res1 = 0 ;
3179       int argvi = 0;
3180       std::string *result = 0 ;
3181       dXSARGS;
3182
3183       if ((items < 1) || (items > 1))
3184         {
3185           SWIG_croak("Usage: Video_url_get(self);");
3186         }
3187       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Video, 0 |  0 );
3188       if (!SWIG_IsOK(res1))
3189         {
3190           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Video_url_get" "', argument " "1"" of type '" "Video *""'");
3191         }
3192       arg1 = reinterpret_cast< Video * >(argp1);
3193       result = (std::string *) & ((arg1)->url);
3194       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
3195       argvi++ ;
3196
3197       XSRETURN(argvi);
3198 fail:
3199
3200       SWIG_croak_null();
3201     }
3202   }
3203
3204
3205   XS(_wrap_Video_id_get)
3206   {
3207     {
3208       Video *arg1 = (Video *) 0 ;
3209       void *argp1 = 0 ;
3210       int res1 = 0 ;
3211       int argvi = 0;
3212       std::string *result = 0 ;
3213       dXSARGS;
3214
3215       if ((items < 1) || (items > 1))
3216         {
3217           SWIG_croak("Usage: Video_id_get(self);");
3218         }
3219       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Video, 0 |  0 );
3220       if (!SWIG_IsOK(res1))
3221         {
3222           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Video_id_get" "', argument " "1"" of type '" "Video *""'");
3223         }
3224       arg1 = reinterpret_cast< Video * >(argp1);
3225       result = (std::string *) & ((arg1)->id);
3226       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
3227       argvi++ ;
3228
3229       XSRETURN(argvi);
3230 fail:
3231
3232       SWIG_croak_null();
3233     }
3234   }
3235
3236
3237   XS(_wrap_Video_link_get)
3238   {
3239     {
3240       Video *arg1 = (Video *) 0 ;
3241       void *argp1 = 0 ;
3242       int res1 = 0 ;
3243       int argvi = 0;
3244       Link *result = 0 ;
3245       dXSARGS;
3246
3247       if ((items < 1) || (items > 1))
3248         {
3249           SWIG_croak("Usage: Video_link_get(self);");
3250         }
3251       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Video, 0 |  0 );
3252       if (!SWIG_IsOK(res1))
3253         {
3254           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Video_link_get" "', argument " "1"" of type '" "Video *""'");
3255         }
3256       arg1 = reinterpret_cast< Video * >(argp1);
3257       result = (Link *)& ((arg1)->link);
3258       ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Link, 0 | SWIG_SHADOW);
3259       argvi++ ;
3260
3261       XSRETURN(argvi);
3262 fail:
3263
3264       SWIG_croak_null();
3265     }
3266   }
3267
3268
3269   XS(_wrap_Video_ok_get)
3270   {
3271     {
3272       Video *arg1 = (Video *) 0 ;
3273       void *argp1 = 0 ;
3274       int res1 = 0 ;
3275       int argvi = 0;
3276       bool result;
3277       dXSARGS;
3278
3279       if ((items < 1) || (items > 1))
3280         {
3281           SWIG_croak("Usage: Video_ok_get(self);");
3282         }
3283       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Video, 0 |  0 );
3284       if (!SWIG_IsOK(res1))
3285         {
3286           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Video_ok_get" "', argument " "1"" of type '" "Video *""'");
3287         }
3288       arg1 = reinterpret_cast< Video * >(argp1);
3289       result = (bool) ((arg1)->ok);
3290       ST(argvi) = SWIG_From_bool  SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result));
3291       argvi++ ;
3292
3293       XSRETURN(argvi);
3294 fail:
3295
3296       SWIG_croak_null();
3297     }
3298   }
3299
3300
3301   XS(_wrap_Video_start_time_get)
3302   {
3303     {
3304       Video *arg1 = (Video *) 0 ;
3305       void *argp1 = 0 ;
3306       int res1 = 0 ;
3307       int argvi = 0;
3308       std::string *result = 0 ;
3309       dXSARGS;
3310
3311       if ((items < 1) || (items > 1))
3312         {
3313           SWIG_croak("Usage: Video_start_time_get(self);");
3314         }
3315       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Video, 0 |  0 );
3316       if (!SWIG_IsOK(res1))
3317         {
3318           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Video_start_time_get" "', argument " "1"" of type '" "Video *""'");
3319         }
3320       arg1 = reinterpret_cast< Video * >(argp1);
3321       result = (std::string *) & ((arg1)->start_time);
3322       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
3323       argvi++ ;
3324
3325       XSRETURN(argvi);
3326 fail:
3327
3328       SWIG_croak_null();
3329     }
3330   }
3331
3332
3333   XS(_wrap_delete_Video)
3334   {
3335     {
3336       Video *arg1 = (Video *) 0 ;
3337       void *argp1 = 0 ;
3338       int res1 = 0 ;
3339       int argvi = 0;
3340       dXSARGS;
3341
3342       if ((items < 1) || (items > 1))
3343         {
3344           SWIG_croak("Usage: delete_Video(self);");
3345         }
3346       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Video, SWIG_POINTER_DISOWN |  0 );
3347       if (!SWIG_IsOK(res1))
3348         {
3349           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Video" "', argument " "1"" of type '" "Video *""'");
3350         }
3351       arg1 = reinterpret_cast< Video * >(argp1);
3352       delete arg1;
3353       ST(argvi) = sv_newmortal();
3354
3355       XSRETURN(argvi);
3356 fail:
3357
3358       SWIG_croak_null();
3359     }
3360   }
3361
3362
3363   XS(_wrap_new_Query)
3364   {
3365     {
3366       int argvi = 0;
3367       Query *result = 0 ;
3368       dXSARGS;
3369
3370       if ((items < 0) || (items > 0))
3371         {
3372           SWIG_croak("Usage: new_Query();");
3373         }
3374       {
3375         try
3376           {
3377             result = (Query *)new Query();
3378           }
3379         catch (const std::runtime_error& e)
3380           {
3381             SWIG_exception (SWIG_RuntimeError, e.what ());
3382           }
3383       }
3384       ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Query, SWIG_OWNER | SWIG_SHADOW);
3385       argvi++ ;
3386       XSRETURN(argvi);
3387 fail:
3388       SWIG_croak_null();
3389     }
3390   }
3391
3392
3393   XS(_wrap_delete_Query)
3394   {
3395     {
3396       Query *arg1 = (Query *) 0 ;
3397       void *argp1 = 0 ;
3398       int res1 = 0 ;
3399       int argvi = 0;
3400       dXSARGS;
3401
3402       if ((items < 1) || (items > 1))
3403         {
3404           SWIG_croak("Usage: delete_Query(self);");
3405         }
3406       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Query, SWIG_POINTER_DISOWN |  0 );
3407       if (!SWIG_IsOK(res1))
3408         {
3409           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Query" "', argument " "1"" of type '" "Query *""'");
3410         }
3411       arg1 = reinterpret_cast< Query * >(argp1);
3412       {
3413         try
3414           {
3415             delete arg1;
3416           }
3417         catch (const std::runtime_error& e)
3418           {
3419             SWIG_exception (SWIG_RuntimeError, e.what ());
3420           }
3421       }
3422       ST(argvi) = sv_newmortal();
3423
3424       XSRETURN(argvi);
3425 fail:
3426
3427       SWIG_croak_null();
3428     }
3429   }
3430
3431
3432   XS(_wrap_Query_parse)
3433   {
3434     {
3435       Query *arg1 = (Query *) 0 ;
3436       std::string *arg2 = 0 ;
3437       Options *arg3 = 0 ;
3438       void *argp1 = 0 ;
3439       int res1 = 0 ;
3440       int res2 = SWIG_OLDOBJ ;
3441       void *argp3 ;
3442       int res3 = 0 ;
3443       int argvi = 0;
3444       Video result;
3445       dXSARGS;
3446
3447       if ((items < 3) || (items > 3))
3448         {
3449           SWIG_croak("Usage: Query_parse(self,std::string const &,Options const &);");
3450         }
3451       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Query, 0 |  0 );
3452       if (!SWIG_IsOK(res1))
3453         {
3454           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_parse" "', argument " "1"" of type '" "Query *""'");
3455         }
3456       arg1 = reinterpret_cast< Query * >(argp1);
3457       {
3458         std::string *ptr = (std::string *)0;
3459         res2 = SWIG_AsPtr_std_string SWIG_PERL_CALL_ARGS_2(ST(1), &ptr);
3460         if (!SWIG_IsOK(res2))
3461           {
3462             SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Query_parse" "', argument " "2"" of type '" "std::string const &""'");
3463           }
3464         if (!ptr)
3465           {
3466             SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Query_parse" "', argument " "2"" of type '" "std::string const &""'");
3467           }
3468         arg2 = ptr;
3469       }
3470       res3 = SWIG_ConvertPtr(ST(2), &argp3, SWIGTYPE_p_Options,  0 );
3471       if (!SWIG_IsOK(res3))
3472         {
3473           SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Query_parse" "', argument " "3"" of type '" "Options const &""'");
3474         }
3475       if (!argp3)
3476         {
3477           SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Query_parse" "', argument " "3"" of type '" "Options const &""'");
3478         }
3479       arg3 = reinterpret_cast< Options * >(argp3);
3480       {
3481         try
3482           {
3483             result = (arg1)->parse((std::string const &)*arg2,(Options const &)*arg3);
3484           }
3485         catch (const std::runtime_error& e)
3486           {
3487             SWIG_exception (SWIG_RuntimeError, e.what ());
3488           }
3489       }
3490       ST(argvi) = SWIG_NewPointerObj((new Video(static_cast< const Video& >(result))), SWIGTYPE_p_Video, SWIG_POINTER_OWN | SWIG_SHADOW);
3491       argvi++ ;
3492
3493       if (SWIG_IsNewObj(res2)) delete arg2;
3494
3495       XSRETURN(argvi);
3496 fail:
3497
3498       if (SWIG_IsNewObj(res2)) delete arg2;
3499
3500       SWIG_croak_null();
3501     }
3502   }
3503
3504
3505   XS(_wrap_Query_next_website)
3506   {
3507     {
3508       Query *arg1 = (Query *) 0 ;
3509       std::string *arg2 = 0 ;
3510       std::string *arg3 = 0 ;
3511       void *argp1 = 0 ;
3512       int res1 = 0 ;
3513       std::string temp2 ;
3514       int res2 = SWIG_TMPOBJ ;
3515       std::string temp3 ;
3516       int res3 = SWIG_TMPOBJ ;
3517       int argvi = 0;
3518       int result;
3519       dXSARGS;
3520
3521       arg2 = &temp2;
3522       arg3 = &temp3;
3523       if ((items < 1) || (items > 1))
3524         {
3525           SWIG_croak("Usage: Query_next_website(self);");
3526         }
3527       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Query, 0 |  0 );
3528       if (!SWIG_IsOK(res1))
3529         {
3530           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_next_website" "', argument " "1"" of type '" "Query *""'");
3531         }
3532       arg1 = reinterpret_cast< Query * >(argp1);
3533       {
3534         try
3535           {
3536             result = (int)(arg1)->next_website(*arg2,*arg3);
3537           }
3538         catch (const std::runtime_error& e)
3539           {
3540             SWIG_exception (SWIG_RuntimeError, e.what ());
3541           }
3542       }
3543       ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result));
3544       argvi++ ;
3545       if (SWIG_IsTmpObj(res2))
3546         {
3547           if (argvi >= items) EXTEND(sp,1);
3548           ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1((*arg2));
3549           argvi++  ;
3550         }
3551       else
3552         {
3553           int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0) : 0;
3554           if (argvi >= items) EXTEND(sp,1);
3555           ST(argvi) = SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_std__string, new_flags);
3556           argvi++  ;
3557         }
3558       if (SWIG_IsTmpObj(res3))
3559         {
3560           if (argvi >= items) EXTEND(sp,1);
3561           ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1((*arg3));
3562           argvi++  ;
3563         }
3564       else
3565         {
3566           int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0) : 0;
3567           if (argvi >= items) EXTEND(sp,1);
3568           ST(argvi) = SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_std__string, new_flags);
3569           argvi++  ;
3570         }
3571
3572
3573
3574       XSRETURN(argvi);
3575 fail:
3576
3577
3578
3579       SWIG_croak_null();
3580     }
3581   }
3582
3583
3584   XS(_wrap_Query_supported)
3585   {
3586     {
3587       Query *arg1 = (Query *) 0 ;
3588       std::string *arg2 = 0 ;
3589       void *argp1 = 0 ;
3590       int res1 = 0 ;
3591       int res2 = SWIG_OLDOBJ ;
3592       int argvi = 0;
3593       int result;
3594       dXSARGS;
3595
3596       if ((items < 2) || (items > 2))
3597         {
3598           SWIG_croak("Usage: Query_supported(self,std::string const &);");
3599         }
3600       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Query, 0 |  0 );
3601       if (!SWIG_IsOK(res1))
3602         {
3603           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_supported" "', argument " "1"" of type '" "Query *""'");
3604         }
3605       arg1 = reinterpret_cast< Query * >(argp1);
3606       {
3607         std::string *ptr = (std::string *)0;
3608         res2 = SWIG_AsPtr_std_string SWIG_PERL_CALL_ARGS_2(ST(1), &ptr);
3609         if (!SWIG_IsOK(res2))
3610           {
3611             SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Query_supported" "', argument " "2"" of type '" "std::string const &""'");
3612           }
3613         if (!ptr)
3614           {
3615             SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Query_supported" "', argument " "2"" of type '" "std::string const &""'");
3616           }
3617         arg2 = ptr;
3618       }
3619       {
3620         try
3621           {
3622             result = (int)(arg1)->supported((std::string const &)*arg2);
3623           }
3624         catch (const std::runtime_error& e)
3625           {
3626             SWIG_exception (SWIG_RuntimeError, e.what ());
3627           }
3628       }
3629       ST(argvi) = SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(result));
3630       argvi++ ;
3631
3632       if (SWIG_IsNewObj(res2)) delete arg2;
3633       XSRETURN(argvi);
3634 fail:
3635
3636       if (SWIG_IsNewObj(res2)) delete arg2;
3637       SWIG_croak_null();
3638     }
3639   }
3640
3641
3642   XS(_wrap_Query_last_error_get)
3643   {
3644     {
3645       Query *arg1 = (Query *) 0 ;
3646       void *argp1 = 0 ;
3647       int res1 = 0 ;
3648       int argvi = 0;
3649       std::string *result = 0 ;
3650       dXSARGS;
3651
3652       if ((items < 1) || (items > 1))
3653         {
3654           SWIG_croak("Usage: Query_last_error_get(self);");
3655         }
3656       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Query, 0 |  0 );
3657       if (!SWIG_IsOK(res1))
3658         {
3659           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_last_error_get" "', argument " "1"" of type '" "Query *""'");
3660         }
3661       arg1 = reinterpret_cast< Query * >(argp1);
3662       result = (std::string *) & ((arg1)->last_error);
3663       ST(argvi) = SWIG_From_std_string  SWIG_PERL_CALL_ARGS_1(static_cast< std::string >(*result));
3664       argvi++ ;
3665
3666       XSRETURN(argvi);
3667 fail:
3668
3669       SWIG_croak_null();
3670     }
3671   }
3672
3673
3674   XS(_wrap_Query_quvi_code_get)
3675   {
3676     {
3677       Query *arg1 = (Query *) 0 ;
3678       void *argp1 = 0 ;
3679       int res1 = 0 ;
3680       int argvi = 0;
3681       long result;
3682       dXSARGS;
3683
3684       if ((items < 1) || (items > 1))
3685         {
3686           SWIG_croak("Usage: Query_quvi_code_get(self);");
3687         }
3688       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Query, 0 |  0 );
3689       if (!SWIG_IsOK(res1))
3690         {
3691           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_quvi_code_get" "', argument " "1"" of type '" "Query *""'");
3692         }
3693       arg1 = reinterpret_cast< Query * >(argp1);
3694       result = (long) ((arg1)->quvi_code);
3695       ST(argvi) = SWIG_From_long  SWIG_PERL_CALL_ARGS_1(static_cast< long >(result));
3696       argvi++ ;
3697
3698       XSRETURN(argvi);
3699 fail:
3700
3701       SWIG_croak_null();
3702     }
3703   }
3704
3705
3706   XS(_wrap_Query_resp_code_get)
3707   {
3708     {
3709       Query *arg1 = (Query *) 0 ;
3710       void *argp1 = 0 ;
3711       int res1 = 0 ;
3712       int argvi = 0;
3713       long result;
3714       dXSARGS;
3715
3716       if ((items < 1) || (items > 1))
3717         {
3718           SWIG_croak("Usage: Query_resp_code_get(self);");
3719         }
3720       res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Query, 0 |  0 );
3721       if (!SWIG_IsOK(res1))
3722         {
3723           SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Query_resp_code_get" "', argument " "1"" of type '" "Query *""'");
3724         }
3725       arg1 = reinterpret_cast< Query * >(argp1);
3726       result = (long) ((arg1)->resp_code);
3727       ST(argvi) = SWIG_From_long  SWIG_PERL_CALL_ARGS_1(static_cast< long >(result));
3728       argvi++ ;
3729
3730       XSRETURN(argvi);
3731 fail:
3732
3733       SWIG_croak_null();
3734     }
3735   }
3736
3737
3738
3739   /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3740
3741   static swig_type_info _swigt__p_Link = {"_p_Link", "Link *", 0, 0, (void*)"WWW::Quvi::Link", 0};
3742   static swig_type_info _swigt__p_Options = {"_p_Options", "Options *", 0, 0, (void*)"WWW::Quvi::Options", 0};
3743   static swig_type_info _swigt__p_Query = {"_p_Query", "Query *", 0, 0, (void*)"WWW::Quvi::Query", 0};
3744   static swig_type_info _swigt__p_Video = {"_p_Video", "Video *", 0, 0, (void*)"WWW::Quvi::Video", 0};
3745   static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
3746   static swig_type_info _swigt__p_quviCategory = {"_p_quviCategory", "enum quviCategory *|quviCategory *", 0, 0, (void*)0, 0};
3747   static swig_type_info _swigt__p_quviCode = {"_p_quviCode", "enum quviCode *|quviCode *", 0, 0, (void*)0, 0};
3748   static swig_type_info _swigt__p_quviVersion = {"_p_quviVersion", "enum quviVersion *|quviVersion *", 0, 0, (void*)0, 0};
3749   static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
3750
3751   static swig_type_info *swig_type_initial[] =
3752   {
3753     &_swigt__p_Link,
3754     &_swigt__p_Options,
3755     &_swigt__p_Query,
3756     &_swigt__p_Video,
3757     &_swigt__p_char,
3758     &_swigt__p_quviCategory,
3759     &_swigt__p_quviCode,
3760     &_swigt__p_quviVersion,
3761     &_swigt__p_std__string,
3762   };
3763
3764   static swig_cast_info _swigc__p_Link[] = {  {&_swigt__p_Link, 0, 0, 0},{0, 0, 0, 0}};
3765   static swig_cast_info _swigc__p_Options[] = {  {&_swigt__p_Options, 0, 0, 0},{0, 0, 0, 0}};
3766   static swig_cast_info _swigc__p_Query[] = {  {&_swigt__p_Query, 0, 0, 0},{0, 0, 0, 0}};
3767   static swig_cast_info _swigc__p_Video[] = {  {&_swigt__p_Video, 0, 0, 0},{0, 0, 0, 0}};
3768   static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3769   static swig_cast_info _swigc__p_quviCategory[] = {  {&_swigt__p_quviCategory, 0, 0, 0},{0, 0, 0, 0}};
3770   static swig_cast_info _swigc__p_quviCode[] = {  {&_swigt__p_quviCode, 0, 0, 0},{0, 0, 0, 0}};
3771   static swig_cast_info _swigc__p_quviVersion[] = {  {&_swigt__p_quviVersion, 0, 0, 0},{0, 0, 0, 0}};
3772   static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
3773
3774   static swig_cast_info *swig_cast_initial[] =
3775   {
3776     _swigc__p_Link,
3777     _swigc__p_Options,
3778     _swigc__p_Query,
3779     _swigc__p_Video,
3780     _swigc__p_char,
3781     _swigc__p_quviCategory,
3782     _swigc__p_quviCode,
3783     _swigc__p_quviVersion,
3784     _swigc__p_std__string,
3785   };
3786
3787
3788   /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3789
3790   static swig_constant_info swig_constants[] =
3791   {
3792     {0,0,0,0,0,0}
3793   };
3794 #ifdef __cplusplus
3795 }
3796 #endif
3797 static swig_variable_info swig_variables[] =
3798 {
3799   { "WWW::Quvic::_VERSION", MAGIC_CLASS _wrap__VERSION_set, MAGIC_CLASS _wrap__VERSION_get,0 },
3800   {0,0,0,0}
3801 };
3802 static swig_command_info swig_commands[] =
3803 {
3804   {"WWW::Quvic::version", _wrap_version},
3805   {"WWW::Quvic::new_Options", _wrap_new_Options},
3806   {"WWW::Quvic::Options_user_agent_set", _wrap_Options_user_agent_set},
3807   {"WWW::Quvic::Options_user_agent_get", _wrap_Options_user_agent_get},
3808   {"WWW::Quvic::Options_http_proxy_set", _wrap_Options_http_proxy_set},
3809   {"WWW::Quvic::Options_http_proxy_get", _wrap_Options_http_proxy_get},
3810   {"WWW::Quvic::Options_verbose_libcurl_set", _wrap_Options_verbose_libcurl_set},
3811   {"WWW::Quvic::Options_verbose_libcurl_get", _wrap_Options_verbose_libcurl_get},
3812   {"WWW::Quvic::Options_format_set", _wrap_Options_format_set},
3813   {"WWW::Quvic::Options_format_get", _wrap_Options_format_get},
3814   {"WWW::Quvic::Options_verify_set", _wrap_Options_verify_set},
3815   {"WWW::Quvic::Options_verify_get", _wrap_Options_verify_get},
3816   {"WWW::Quvic::Options_shortened_set", _wrap_Options_shortened_set},
3817   {"WWW::Quvic::Options_shortened_get", _wrap_Options_shortened_get},
3818   {"WWW::Quvic::Options_category_set", _wrap_Options_category_set},
3819   {"WWW::Quvic::Options_category_get", _wrap_Options_category_get},
3820   {"WWW::Quvic::delete_Options", _wrap_delete_Options},
3821   {"WWW::Quvic::new_Link", _wrap_new_Link},
3822   {"WWW::Quvic::Link_content_type_get", _wrap_Link_content_type_get},
3823   {"WWW::Quvic::Link_file_suffix_get", _wrap_Link_file_suffix_get},
3824   {"WWW::Quvic::Link_length_bytes_get", _wrap_Link_length_bytes_get},
3825   {"WWW::Quvic::Link_url_get", _wrap_Link_url_get},
3826   {"WWW::Quvic::delete_Link", _wrap_delete_Link},
3827   {"WWW::Quvic::new_Video", _wrap_new_Video},
3828   {"WWW::Quvic::Video_title_get", _wrap_Video_title_get},
3829   {"WWW::Quvic::Video_host_get", _wrap_Video_host_get},
3830   {"WWW::Quvic::Video_url_get", _wrap_Video_url_get},
3831   {"WWW::Quvic::Video_id_get", _wrap_Video_id_get},
3832   {"WWW::Quvic::Video_link_get", _wrap_Video_link_get},
3833   {"WWW::Quvic::Video_ok_get", _wrap_Video_ok_get},
3834   {"WWW::Quvic::Video_start_time_get", _wrap_Video_start_time_get},
3835   {"WWW::Quvic::delete_Video", _wrap_delete_Video},
3836   {"WWW::Quvic::new_Query", _wrap_new_Query},
3837   {"WWW::Quvic::delete_Query", _wrap_delete_Query},
3838   {"WWW::Quvic::Query_parse", _wrap_Query_parse},
3839   {"WWW::Quvic::Query_next_website", _wrap_Query_next_website},
3840   {"WWW::Quvic::Query_supported", _wrap_Query_supported},
3841   {"WWW::Quvic::Query_last_error_get", _wrap_Query_last_error_get},
3842   {"WWW::Quvic::Query_quvi_code_get", _wrap_Query_quvi_code_get},
3843   {"WWW::Quvic::Query_resp_code_get", _wrap_Query_resp_code_get},
3844   {0,0}
3845 };
3846 /* -----------------------------------------------------------------------------
3847  * Type initialization:
3848  * This problem is tough by the requirement that no dynamic
3849  * memory is used. Also, since swig_type_info structures store pointers to
3850  * swig_cast_info structures and swig_cast_info structures store pointers back
3851  * to swig_type_info structures, we need some lookup code at initialization.
3852  * The idea is that swig generates all the structures that are needed.
3853  * The runtime then collects these partially filled structures.
3854  * The SWIG_InitializeModule function takes these initial arrays out of
3855  * swig_module, and does all the lookup, filling in the swig_module.types
3856  * array with the correct data and linking the correct swig_cast_info
3857  * structures together.
3858  *
3859  * The generated swig_type_info structures are assigned staticly to an initial
3860  * array. We just loop through that array, and handle each type individually.
3861  * First we lookup if this type has been already loaded, and if so, use the
3862  * loaded structure instead of the generated one. Then we have to fill in the
3863  * cast linked list. The cast data is initially stored in something like a
3864  * two-dimensional array. Each row corresponds to a type (there are the same
3865  * number of rows as there are in the swig_type_initial array). Each entry in
3866  * a column is one of the swig_cast_info structures for that type.
3867  * The cast_initial array is actually an array of arrays, because each row has
3868  * a variable number of columns. So to actually build the cast linked list,
3869  * we find the array of casts associated with the type, and loop through it
3870  * adding the casts to the list. The one last trick we need to do is making
3871  * sure the type pointer in the swig_cast_info struct is correct.
3872  *
3873  * First off, we lookup the cast->type name to see if it is already loaded.
3874  * There are three cases to handle:
3875  *  1) If the cast->type has already been loaded AND the type we are adding
3876  *     casting info to has not been loaded (it is in this module), THEN we
3877  *     replace the cast->type pointer with the type pointer that has already
3878  *     been loaded.
3879  *  2) If BOTH types (the one we are adding casting info to, and the
3880  *     cast->type) are loaded, THEN the cast info has already been loaded by
3881  *     the previous module so we just ignore it.
3882  *  3) Finally, if cast->type has not already been loaded, then we add that
3883  *     swig_cast_info to the linked list (because the cast->type) pointer will
3884  *     be correct.
3885  * ----------------------------------------------------------------------------- */
3886
3887 #ifdef __cplusplus
3888 extern "C" {
3889 #if 0
3890 } /* c-mode */
3891 #endif
3892 #endif
3893
3894 #if 0
3895 #define SWIGRUNTIME_DEBUG
3896 #endif
3897
3898
3899 SWIGRUNTIME void
3900 SWIG_InitializeModule(void *clientdata)
3901 {
3902   size_t i;
3903   swig_module_info *module_head, *iter;
3904   int found, init;
3905
3906   clientdata = clientdata;
3907
3908   /* check to see if the circular list has been setup, if not, set it up */
3909   if (swig_module.next==0)
3910     {
3911       /* Initialize the swig_module */
3912       swig_module.type_initial = swig_type_initial;
3913       swig_module.cast_initial = swig_cast_initial;
3914       swig_module.next = &swig_module;
3915       init = 1;
3916     }
3917   else
3918     {
3919       init = 0;
3920     }
3921
3922   /* Try and load any already created modules */
3923   module_head = SWIG_GetModule(clientdata);
3924   if (!module_head)
3925     {
3926       /* This is the first module loaded for this interpreter */
3927       /* so set the swig module into the interpreter */
3928       SWIG_SetModule(clientdata, &swig_module);
3929       module_head = &swig_module;
3930     }
3931   else
3932     {
3933       /* the interpreter has loaded a SWIG module, but has it loaded this one? */
3934       found=0;
3935       iter=module_head;
3936       do
3937         {
3938           if (iter==&swig_module)
3939             {
3940               found=1;
3941               break;
3942             }
3943           iter=iter->next;
3944         }
3945       while (iter!= module_head);
3946
3947       /* if the is found in the list, then all is done and we may leave */
3948       if (found) return;
3949       /* otherwise we must add out module into the list */
3950       swig_module.next = module_head->next;
3951       module_head->next = &swig_module;
3952     }
3953
3954   /* When multiple interpeters are used, a module could have already been initialized in
3955        a different interpreter, but not yet have a pointer in this interpreter.
3956        In this case, we do not want to continue adding types... everything should be
3957        set up already */
3958   if (init == 0) return;
3959
3960   /* Now work on filling in swig_module.types */
3961 #ifdef SWIGRUNTIME_DEBUG
3962   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
3963 #endif
3964   for (i = 0; i < swig_module.size; ++i)
3965     {
3966       swig_type_info *type = 0;
3967       swig_type_info *ret;
3968       swig_cast_info *cast;
3969
3970 #ifdef SWIGRUNTIME_DEBUG
3971       printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3972 #endif
3973
3974       /* if there is another module already loaded */
3975       if (swig_module.next != &swig_module)
3976         {
3977           type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3978         }
3979       if (type)
3980         {
3981           /* Overwrite clientdata field */
3982 #ifdef SWIGRUNTIME_DEBUG
3983           printf("SWIG_InitializeModule: found type %s\n", type->name);
3984 #endif
3985           if (swig_module.type_initial[i]->clientdata)
3986             {
3987               type->clientdata = swig_module.type_initial[i]->clientdata;
3988 #ifdef SWIGRUNTIME_DEBUG
3989               printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3990 #endif
3991             }
3992         }
3993       else
3994         {
3995           type = swig_module.type_initial[i];
3996         }
3997
3998       /* Insert casting types */
3999       cast = swig_module.cast_initial[i];
4000       while (cast->type)
4001         {
4002           /* Don't need to add information already in the list */
4003           ret = 0;
4004 #ifdef SWIGRUNTIME_DEBUG
4005           printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4006 #endif
4007           if (swig_module.next != &swig_module)
4008             {
4009               ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4010 #ifdef SWIGRUNTIME_DEBUG
4011               if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4012 #endif
4013             }
4014           if (ret)
4015             {
4016               if (type == swig_module.type_initial[i])
4017                 {
4018 #ifdef SWIGRUNTIME_DEBUG
4019                   printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4020 #endif
4021                   cast->type = ret;
4022                   ret = 0;
4023                 }
4024               else
4025                 {
4026                   /* Check for casting already in the list */
4027                   swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4028 #ifdef SWIGRUNTIME_DEBUG
4029                   if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4030 #endif
4031                   if (!ocast) ret = 0;
4032                 }
4033             }
4034
4035           if (!ret)
4036             {
4037 #ifdef SWIGRUNTIME_DEBUG
4038               printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4039 #endif
4040               if (type->cast)
4041                 {
4042                   type->cast->prev = cast;
4043                   cast->next = type->cast;
4044                 }
4045               type->cast = cast;
4046             }
4047           cast++;
4048         }
4049       /* Set entry in modules->types array equal to the type */
4050       swig_module.types[i] = type;
4051     }
4052   swig_module.types[i] = 0;
4053
4054 #ifdef SWIGRUNTIME_DEBUG
4055   printf("**** SWIG_InitializeModule: Cast List ******\n");
4056   for (i = 0; i < swig_module.size; ++i)
4057     {
4058       int j = 0;
4059       swig_cast_info *cast = swig_module.cast_initial[i];
4060       printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4061       while (cast->type)
4062         {
4063           printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4064           cast++;
4065           ++j;
4066         }
4067       printf("---- Total casts: %d\n",j);
4068     }
4069   printf("**** SWIG_InitializeModule: Cast List ******\n");
4070 #endif
4071 }
4072
4073 /* This function will propagate the clientdata field of type to
4074 * any new swig_type_info structures that have been added into the list
4075 * of equivalent types.  It is like calling
4076 * SWIG_TypeClientData(type, clientdata) a second time.
4077 */
4078 SWIGRUNTIME void
4079 SWIG_PropagateClientData(void)
4080 {
4081   size_t i;
4082   swig_cast_info *equiv;
4083   static int init_run = 0;
4084
4085   if (init_run) return;
4086   init_run = 1;
4087
4088   for (i = 0; i < swig_module.size; i++)
4089     {
4090       if (swig_module.types[i]->clientdata)
4091         {
4092           equiv = swig_module.types[i]->cast;
4093           while (equiv)
4094             {
4095               if (!equiv->converter)
4096                 {
4097                   if (equiv->type && !equiv->type->clientdata)
4098                     SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4099                 }
4100               equiv = equiv->next;
4101             }
4102         }
4103     }
4104 }
4105
4106 #ifdef __cplusplus
4107 #if 0
4108 {
4109   /* c-mode */
4110 #endif
4111 }
4112 #endif
4113
4114
4115
4116 #ifdef __cplusplus
4117 extern "C"
4118 #endif
4119
4120 XS(SWIG_init)
4121 {
4122   dXSARGS;
4123   int i;
4124
4125   SWIG_InitializeModule(0);
4126
4127   /* Install commands */
4128   for (i = 0; swig_commands[i].name; i++)
4129     {
4130       newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
4131     }
4132
4133   /* Install variables */
4134   for (i = 0; swig_variables[i].name; i++)
4135     {
4136       SV *sv;
4137       sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
4138       if (swig_variables[i].type)
4139         {
4140           SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
4141         }
4142       else
4143         {
4144           sv_setiv(sv,(IV) 0);
4145         }
4146       swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
4147     }
4148
4149   /* Install constant */
4150   for (i = 0; swig_constants[i].type; i++)
4151     {
4152       SV *sv;
4153       sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
4154       switch(swig_constants[i].type)
4155         {
4156         case SWIG_INT:
4157           sv_setiv(sv, (IV) swig_constants[i].lvalue);
4158           break;
4159         case SWIG_FLOAT:
4160           sv_setnv(sv, (double) swig_constants[i].dvalue);
4161           break;
4162         case SWIG_STRING:
4163           sv_setpv(sv, (char *) swig_constants[i].pvalue);
4164           break;
4165         case SWIG_POINTER:
4166           SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
4167           break;
4168         case SWIG_BINARY:
4169           SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
4170           break;
4171         default:
4172           break;
4173         }
4174       SvREADONLY_on(sv);
4175     }
4176
4177   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/ do
4178     {
4179       SV *sv = get_sv((char*) SWIG_prefix "libquviVersion", TRUE | 0x2 | GV_ADDMULTI);
4180       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(libquviVersion)));
4181       SvREADONLY_on(sv);
4182     }
4183   while(0) /*@SWIG@*/;
4184   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4185   do
4186     {
4187       SV *sv = get_sv((char*) SWIG_prefix "libquviVersionLong", TRUE | 0x2 | GV_ADDMULTI);
4188       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(libquviVersionLong)));
4189       SvREADONLY_on(sv);
4190     }
4191   while(0) /*@SWIG@*/;
4192   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4193   do
4194     {
4195       SV *sv = get_sv((char*) SWIG_prefix "ModuleVersion", TRUE | 0x2 | GV_ADDMULTI);
4196       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(ModuleVersion)));
4197       SvREADONLY_on(sv);
4198     }
4199   while(0) /*@SWIG@*/;
4200   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4201   do
4202     {
4203       SV *sv = get_sv((char*) SWIG_prefix "OK", TRUE | 0x2 | GV_ADDMULTI);
4204       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(OK)));
4205       SvREADONLY_on(sv);
4206     }
4207   while(0) /*@SWIG@*/;
4208   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4209   do
4210     {
4211       SV *sv = get_sv((char*) SWIG_prefix "Mem", TRUE | 0x2 | GV_ADDMULTI);
4212       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(Mem)));
4213       SvREADONLY_on(sv);
4214     }
4215   while(0) /*@SWIG@*/;
4216   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4217   do
4218     {
4219       SV *sv = get_sv((char*) SWIG_prefix "BadHandle", TRUE | 0x2 | GV_ADDMULTI);
4220       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(BadHandle)));
4221       SvREADONLY_on(sv);
4222     }
4223   while(0) /*@SWIG@*/;
4224   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4225   do
4226     {
4227       SV *sv = get_sv((char*) SWIG_prefix "InvArg", TRUE | 0x2 | GV_ADDMULTI);
4228       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(InvArg)));
4229       SvREADONLY_on(sv);
4230     }
4231   while(0) /*@SWIG@*/;
4232   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4233   do
4234     {
4235       SV *sv = get_sv((char*) SWIG_prefix "CurlInit", TRUE | 0x2 | GV_ADDMULTI);
4236       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(CurlInit)));
4237       SvREADONLY_on(sv);
4238     }
4239   while(0) /*@SWIG@*/;
4240   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4241   do
4242     {
4243       SV *sv = get_sv((char*) SWIG_prefix "Last", TRUE | 0x2 | GV_ADDMULTI);
4244       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(Last)));
4245       SvREADONLY_on(sv);
4246     }
4247   while(0) /*@SWIG@*/;
4248   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4249   do
4250     {
4251       SV *sv = get_sv((char*) SWIG_prefix "AbortedByCallback", TRUE | 0x2 | GV_ADDMULTI);
4252       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(AbortedByCallback)));
4253       SvREADONLY_on(sv);
4254     }
4255   while(0) /*@SWIG@*/;
4256   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4257   do
4258     {
4259       SV *sv = get_sv((char*) SWIG_prefix "LuaInit", TRUE | 0x2 | GV_ADDMULTI);
4260       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(LuaInit)));
4261       SvREADONLY_on(sv);
4262     }
4263   while(0) /*@SWIG@*/;
4264   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4265   do
4266     {
4267       SV *sv = get_sv((char*) SWIG_prefix "NoLuaWebsite", TRUE | 0x2 | GV_ADDMULTI);
4268       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(NoLuaWebsite)));
4269       SvREADONLY_on(sv);
4270     }
4271   while(0) /*@SWIG@*/;
4272   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4273   do
4274     {
4275       SV *sv = get_sv((char*) SWIG_prefix "NoLuaUtil", TRUE | 0x2 | GV_ADDMULTI);
4276       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(NoLuaUtil)));
4277       SvREADONLY_on(sv);
4278     }
4279   while(0) /*@SWIG@*/;
4280   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4281   do
4282     {
4283       SV *sv = get_sv((char*) SWIG_prefix "PcreError", TRUE | 0x2 | GV_ADDMULTI);
4284       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(PcreError)));
4285       SvREADONLY_on(sv);
4286     }
4287   while(0) /*@SWIG@*/;
4288   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4289   do
4290     {
4291       SV *sv = get_sv((char*) SWIG_prefix "NoSupport", TRUE | 0x2 | GV_ADDMULTI);
4292       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(NoSupport)));
4293       SvREADONLY_on(sv);
4294     }
4295   while(0) /*@SWIG@*/;
4296   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4297   do
4298     {
4299       SV *sv = get_sv((char*) SWIG_prefix "CurlError", TRUE | 0x2 | GV_ADDMULTI);
4300       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(CurlError)));
4301       SvREADONLY_on(sv);
4302     }
4303   while(0) /*@SWIG@*/;
4304   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4305   do
4306     {
4307       SV *sv = get_sv((char*) SWIG_prefix "IconvError", TRUE | 0x2 | GV_ADDMULTI);
4308       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(IconvError)));
4309       SvREADONLY_on(sv);
4310     }
4311   while(0) /*@SWIG@*/;
4312   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4313   do
4314     {
4315       SV *sv = get_sv((char*) SWIG_prefix "LuaError", TRUE | 0x2 | GV_ADDMULTI);
4316       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(LuaError)));
4317       SvREADONLY_on(sv);
4318     }
4319   while(0) /*@SWIG@*/;
4320   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4321   do
4322     {
4323       SV *sv = get_sv((char*) SWIG_prefix "ProtoHttp", TRUE | 0x2 | GV_ADDMULTI);
4324       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(ProtoHttp)));
4325       SvREADONLY_on(sv);
4326     }
4327   while(0) /*@SWIG@*/;
4328   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4329   do
4330     {
4331       SV *sv = get_sv((char*) SWIG_prefix "ProtoMms", TRUE | 0x2 | GV_ADDMULTI);
4332       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(ProtoMms)));
4333       SvREADONLY_on(sv);
4334     }
4335   while(0) /*@SWIG@*/;
4336   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4337   do
4338     {
4339       SV *sv = get_sv((char*) SWIG_prefix "ProtoRtsp", TRUE | 0x2 | GV_ADDMULTI);
4340       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(ProtoRtsp)));
4341       SvREADONLY_on(sv);
4342     }
4343   while(0) /*@SWIG@*/;
4344   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4345   do
4346     {
4347       SV *sv = get_sv((char*) SWIG_prefix "ProtoRtmp", TRUE | 0x2 | GV_ADDMULTI);
4348       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(ProtoRtmp)));
4349       SvREADONLY_on(sv);
4350     }
4351   while(0) /*@SWIG@*/;
4352   /*@SWIG:/usr/share/swig/2.0.2/perl5/perltypemaps.swg,65,%set_constant@*/
4353   do
4354     {
4355       SV *sv = get_sv((char*) SWIG_prefix "ProtoAll", TRUE | 0x2 | GV_ADDMULTI);
4356       sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1(static_cast< int >(ProtoAll)));
4357       SvREADONLY_on(sv);
4358     }
4359   while(0) /*@SWIG@*/;
4360   SWIG_TypeClientData(SWIGTYPE_p_Options, (void*) "WWW::Quvi::Options");
4361   SWIG_TypeClientData(SWIGTYPE_p_Link, (void*) "WWW::Quvi::Link");
4362   SWIG_TypeClientData(SWIGTYPE_p_Video, (void*) "WWW::Quvi::Video");
4363   SWIG_TypeClientData(SWIGTYPE_p_Query, (void*) "WWW::Quvi::Query");
4364   ST(0) = &PL_sv_yes;
4365   XSRETURN(1);
4366 }
4367