git.gag.com Git - debian/gnuradio/blob - gr-howto-write-a-block/swig/howto.cc

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.36
   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 SWIGPYTHON
  12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
  13
  14 #ifdef __cplusplus
  15 template<typename T> class SwigValueWrapper {
  16     T *tt;
  17 public:
  18     SwigValueWrapper() : tt(0) { }
  19     SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
  20     SwigValueWrapper(const T& t) : tt(new T(t)) { }
  21     ~SwigValueWrapper() { delete tt; }
  22     SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
  23     operator T&() const { return *tt; }
  24     T *operator&() { return tt; }
  25 private:
  26     SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27 };
  28
  29 template <typename T> T SwigValueInit() {
  30   return T();
  31 }
  32 #endif
  33
  34 /* -----------------------------------------------------------------------------
  35  *  This section contains generic SWIG labels for method/variable
  36  *  declarations/attributes, and other compiler dependent labels.
  37  * ----------------------------------------------------------------------------- */
  38
  39 /* template workaround for compilers that cannot correctly implement the C++ standard */
  40 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  41 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  42 #  define SWIGTEMPLATEDISAMBIGUATOR template
  43 # elif defined(__HP_aCC)
  44 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  45 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  46 #  define SWIGTEMPLATEDISAMBIGUATOR template
  47 # else
  48 #  define SWIGTEMPLATEDISAMBIGUATOR
  49 # endif
  50 #endif
  51
  52 /* inline attribute */
  53 #ifndef SWIGINLINE
  54 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  55 #   define SWIGINLINE inline
  56 # else
  57 #   define SWIGINLINE
  58 # endif
  59 #endif
  60
  61 /* attribute recognised by some compilers to avoid 'unused' warnings */
  62 #ifndef SWIGUNUSED
  63 # if defined(__GNUC__)
  64 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  65 #     define SWIGUNUSED __attribute__ ((__unused__))
  66 #   else
  67 #     define SWIGUNUSED
  68 #   endif
  69 # elif defined(__ICC)
  70 #   define SWIGUNUSED __attribute__ ((__unused__))
  71 # else
  72 #   define SWIGUNUSED
  73 # endif
  74 #endif
  75
  76 #ifndef SWIG_MSC_UNSUPPRESS_4505
  77 # if defined(_MSC_VER)
  78 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  79 # endif
  80 #endif
  81
  82 #ifndef SWIGUNUSEDPARM
  83 # ifdef __cplusplus
  84 #   define SWIGUNUSEDPARM(p)
  85 # else
  86 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  87 # endif
  88 #endif
  89
  90 /* internal SWIG method */
  91 #ifndef SWIGINTERN
  92 # define SWIGINTERN static SWIGUNUSED
  93 #endif
  94
  95 /* internal inline SWIG method */
  96 #ifndef SWIGINTERNINLINE
  97 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  98 #endif
  99
 100 /* exporting methods */
 101 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 102 #  ifndef GCC_HASCLASSVISIBILITY
 103 #    define GCC_HASCLASSVISIBILITY
 104 #  endif
 105 #endif
 106
 107 #ifndef SWIGEXPORT
 108 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 109 #   if defined(STATIC_LINKED)
 110 #     define SWIGEXPORT
 111 #   else
 112 #     define SWIGEXPORT __declspec(dllexport)
 113 #   endif
 114 # else
 115 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 116 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 117 #   else
 118 #     define SWIGEXPORT
 119 #   endif
 120 # endif
 121 #endif
 122
 123 /* calling conventions for Windows */
 124 #ifndef SWIGSTDCALL
 125 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 126 #   define SWIGSTDCALL __stdcall
 127 # else
 128 #   define SWIGSTDCALL
 129 # endif
 130 #endif
 131
 132 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 133 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 134 # define _CRT_SECURE_NO_DEPRECATE
 135 #endif
 136
 137 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 138 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 139 # define _SCL_SECURE_NO_DEPRECATE
 140 #endif
 141
 142
 143
 144 /* Python.h has to appear first */
 145 #include <Python.h>
 146
 147 /* -----------------------------------------------------------------------------
 148  * swigrun.swg
 149  *
 150  * This file contains generic CAPI SWIG runtime support for pointer
 151  * type checking.
 152  * ----------------------------------------------------------------------------- */
 153
 154 /* This should only be incremented when either the layout of swig_type_info changes,
 155    or for whatever reason, the runtime changes incompatibly */
 156 #define SWIG_RUNTIME_VERSION "4"
 157
 158 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 159 #ifdef SWIG_TYPE_TABLE
 160 # define SWIG_QUOTE_STRING(x) #x
 161 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 162 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 163 #else
 164 # define SWIG_TYPE_TABLE_NAME
 165 #endif
 166
 167 /*
 168   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 169   creating a static or dynamic library from the swig runtime code.
 170   In 99.9% of the cases, swig just needs to declare them as 'static'.
 171
 172   But only do this if is strictly necessary, ie, if you have problems
 173   with your compiler or so.
 174 */
 175
 176 #ifndef SWIGRUNTIME
 177 # define SWIGRUNTIME SWIGINTERN
 178 #endif
 179
 180 #ifndef SWIGRUNTIMEINLINE
 181 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 182 #endif
 183
 184 /*  Generic buffer size */
 185 #ifndef SWIG_BUFFER_SIZE
 186 # define SWIG_BUFFER_SIZE 1024
 187 #endif
 188
 189 /* Flags for pointer conversions */
 190 #define SWIG_POINTER_DISOWN        0x1
 191 #define SWIG_CAST_NEW_MEMORY       0x2
 192
 193 /* Flags for new pointer objects */
 194 #define SWIG_POINTER_OWN           0x1
 195
 196
 197 /*
 198    Flags/methods for returning states.
 199
 200    The swig conversion methods, as ConvertPtr, return and integer
 201    that tells if the conversion was successful or not. And if not,
 202    an error code can be returned (see swigerrors.swg for the codes).
 203
 204    Use the following macros/flags to set or process the returning
 205    states.
 206
 207    In old swig versions, you usually write code as:
 208
 209      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 210        // success code
 211      } else {
 212        //fail code
 213      }
 214
 215    Now you can be more explicit as:
 216
 217     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 218     if (SWIG_IsOK(res)) {
 219       // success code
 220     } else {
 221       // fail code
 222     }
 223
 224    that seems to be the same, but now you can also do
 225
 226     Type *ptr;
 227     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 228     if (SWIG_IsOK(res)) {
 229       // success code
 230       if (SWIG_IsNewObj(res) {
 231         ...
 232         delete *ptr;
 233       } else {
 234         ...
 235       }
 236     } else {
 237       // fail code
 238     }
 239
 240    I.e., now SWIG_ConvertPtr can return new objects and you can
 241    identify the case and take care of the deallocation. Of course that
 242    requires also to SWIG_ConvertPtr to return new result values, as
 243
 244       int SWIG_ConvertPtr(obj, ptr,...) {
 245         if (<obj is ok>) {
 246           if (<need new object>) {
 247             *ptr = <ptr to new allocated object>;
 248             return SWIG_NEWOBJ;
 249           } else {
 250             *ptr = <ptr to old object>;
 251             return SWIG_OLDOBJ;
 252           }
 253         } else {
 254           return SWIG_BADOBJ;
 255         }
 256       }
 257
 258    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 259    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 260    swig errors code.
 261
 262    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 263    allows to return the 'cast rank', for example, if you have this
 264
 265        int food(double)
 266        int fooi(int);
 267
 268    and you call
 269
 270       food(1)   // cast rank '1'  (1 -> 1.0)
 271       fooi(1)   // cast rank '0'
 272
 273    just use the SWIG_AddCast()/SWIG_CheckState()
 274
 275
 276  */
 277 #define SWIG_OK                    (0)
 278 #define SWIG_ERROR                 (-1)
 279 #define SWIG_IsOK(r)               (r >= 0)
 280 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 281
 282 /* The CastRankLimit says how many bits are used for the cast rank */
 283 #define SWIG_CASTRANKLIMIT         (1 << 8)
 284 /* The NewMask denotes the object was created (using new/malloc) */
 285 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 286 /* The TmpMask is for in/out typemaps that use temporal objects */
 287 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 288 /* Simple returning values */
 289 #define SWIG_BADOBJ                (SWIG_ERROR)
 290 #define SWIG_OLDOBJ                (SWIG_OK)
 291 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 292 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 293 /* Check, add and del mask methods */
 294 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 295 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 296 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 297 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 298 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 299 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 300
 301
 302 /* Cast-Rank Mode */
 303 #if defined(SWIG_CASTRANK_MODE)
 304 #  ifndef SWIG_TypeRank
 305 #    define SWIG_TypeRank             unsigned long
 306 #  endif
 307 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 308 #    define SWIG_MAXCASTRANK          (2)
 309 #  endif
 310 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 311 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 312 SWIGINTERNINLINE int SWIG_AddCast(int r) {
 313   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 314 }
 315 SWIGINTERNINLINE int SWIG_CheckState(int r) {
 316   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
 317 }
 318 #else /* no cast-rank mode */
 319 #  define SWIG_AddCast
 320 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 321 #endif
 322
 323
 324
 325
 326 #include <string.h>
 327
 328 #ifdef __cplusplus
 329 extern "C" {
 330 #endif
 331
 332 typedef void *(*swig_converter_func)(void *, int *);
 333 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 334
 335 /* Structure to store information on one type */
 336 typedef struct swig_type_info {
 337   const char             *name;                 /* mangled name of this type */
 338   const char             *str;                  /* human readable name of this type */
 339   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 340   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 341   void                   *clientdata;           /* language specific type data */
 342   int                    owndata;               /* flag if the structure owns the clientdata */
 343 } swig_type_info;
 344
 345 /* Structure to store a type and conversion function used for casting */
 346 typedef struct swig_cast_info {
 347   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 348   swig_converter_func     converter;            /* function to cast the void pointers */
 349   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 350   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 351 } swig_cast_info;
 352
 353 /* Structure used to store module information
 354  * Each module generates one structure like this, and the runtime collects
 355  * all of these structures and stores them in a circularly linked list.*/
 356 typedef struct swig_module_info {
 357   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 358   size_t                 size;                  /* Number of types in this module */
 359   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 360   swig_type_info         **type_initial;        /* Array of initially generated type structures */
 361   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 362   void                    *clientdata;          /* Language specific module data */
 363 } swig_module_info;
 364
 365 /*
 366   Compare two type names skipping the space characters, therefore
 367   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 368
 369   Return 0 when the two name types are equivalent, as in
 370   strncmp, but skipping ' '.
 371 */
 372 SWIGRUNTIME int
 373 SWIG_TypeNameComp(const char *f1, const char *l1,
 374                   const char *f2, const char *l2) {
 375   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 376     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 377     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 378     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 379   }
 380   return (int)((l1 - f1) - (l2 - f2));
 381 }
 382
 383 /*
 384   Check type equivalence in a name list like <name1>|<name2>|...
 385   Return 0 if not equal, 1 if equal
 386 */
 387 SWIGRUNTIME int
 388 SWIG_TypeEquiv(const char *nb, const char *tb) {
 389   int equiv = 0;
 390   const char* te = tb + strlen(tb);
 391   const char* ne = nb;
 392   while (!equiv && *ne) {
 393     for (nb = ne; *ne; ++ne) {
 394       if (*ne == '|') break;
 395     }
 396     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 397     if (*ne) ++ne;
 398   }
 399   return equiv;
 400 }
 401
 402 /*
 403   Check type equivalence in a name list like <name1>|<name2>|...
 404   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 405 */
 406 SWIGRUNTIME int
 407 SWIG_TypeCompare(const char *nb, const char *tb) {
 408   int equiv = 0;
 409   const char* te = tb + strlen(tb);
 410   const char* ne = nb;
 411   while (!equiv && *ne) {
 412     for (nb = ne; *ne; ++ne) {
 413       if (*ne == '|') break;
 414     }
 415     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 416     if (*ne) ++ne;
 417   }
 418   return equiv;
 419 }
 420
 421
 422 /* think of this as a c++ template<> or a scheme macro */
 423 #define SWIG_TypeCheck_Template(comparison, ty)         \
 424   if (ty) {                                             \
 425     swig_cast_info *iter = ty->cast;                    \
 426     while (iter) {                                      \
 427       if (comparison) {                                 \
 428         if (iter == ty->cast) return iter;              \
 429         /* Move iter to the top of the linked list */   \
 430         iter->prev->next = iter->next;                  \
 431         if (iter->next)                                 \
 432           iter->next->prev = iter->prev;                \
 433         iter->next = ty->cast;                          \
 434         iter->prev = 0;                                 \
 435         if (ty->cast) ty->cast->prev = iter;            \
 436         ty->cast = iter;                                \
 437         return iter;                                    \
 438       }                                                 \
 439       iter = iter->next;                                \
 440     }                                                   \
 441   }                                                     \
 442   return 0
 443
 444 /*
 445   Check the typename
 446 */
 447 SWIGRUNTIME swig_cast_info *
 448 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 449   SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 450 }
 451
 452 /* Same as previous function, except strcmp is replaced with a pointer comparison */
 453 SWIGRUNTIME swig_cast_info *
 454 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
 455   SWIG_TypeCheck_Template(iter->type == from, into);
 456 }
 457
 458 /*
 459   Cast a pointer up an inheritance hierarchy
 460 */
 461 SWIGRUNTIMEINLINE void *
 462 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
 463   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 464 }
 465
 466 /*
 467    Dynamic pointer casting. Down an inheritance hierarchy
 468 */
 469 SWIGRUNTIME swig_type_info *
 470 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 471   swig_type_info *lastty = ty;
 472   if (!ty || !ty->dcast) return ty;
 473   while (ty && (ty->dcast)) {
 474     ty = (*ty->dcast)(ptr);
 475     if (ty) lastty = ty;
 476   }
 477   return lastty;
 478 }
 479
 480 /*
 481   Return the name associated with this type
 482 */
 483 SWIGRUNTIMEINLINE const char *
 484 SWIG_TypeName(const swig_type_info *ty) {
 485   return ty->name;
 486 }
 487
 488 /*
 489   Return the pretty name associated with this type,
 490   that is an unmangled type name in a form presentable to the user.
 491 */
 492 SWIGRUNTIME const char *
 493 SWIG_TypePrettyName(const swig_type_info *type) {
 494   /* The "str" field contains the equivalent pretty names of the
 495      type, separated by vertical-bar characters.  We choose
 496      to print the last name, as it is often (?) the most
 497      specific. */
 498   if (!type) return NULL;
 499   if (type->str != NULL) {
 500     const char *last_name = type->str;
 501     const char *s;
 502     for (s = type->str; *s; s++)
 503       if (*s == '|') last_name = s+1;
 504     return last_name;
 505   }
 506   else
 507     return type->name;
 508 }
 509
 510 /*
 511    Set the clientdata field for a type
 512 */
 513 SWIGRUNTIME void
 514 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 515   swig_cast_info *cast = ti->cast;
 516   /* if (ti->clientdata == clientdata) return; */
 517   ti->clientdata = clientdata;
 518
 519   while (cast) {
 520     if (!cast->converter) {
 521       swig_type_info *tc = cast->type;
 522       if (!tc->clientdata) {
 523         SWIG_TypeClientData(tc, clientdata);
 524       }
 525     }
 526     cast = cast->next;
 527   }
 528 }
 529 SWIGRUNTIME void
 530 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 531   SWIG_TypeClientData(ti, clientdata);
 532   ti->owndata = 1;
 533 }
 534
 535 /*
 536   Search for a swig_type_info structure only by mangled name
 537   Search is a O(log #types)
 538
 539   We start searching at module start, and finish searching when start == end.
 540   Note: if start == end at the beginning of the function, we go all the way around
 541   the circular list.
 542 */
 543 SWIGRUNTIME swig_type_info *
 544 SWIG_MangledTypeQueryModule(swig_module_info *start,
 545                             swig_module_info *end,
 546                             const char *name) {
 547   swig_module_info *iter = start;
 548   do {
 549     if (iter->size) {
 550       register size_t l = 0;
 551       register size_t r = iter->size - 1;
 552       do {
 553         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 554         register size_t i = (l + r) >> 1;
 555         const char *iname = iter->types[i]->name;
 556         if (iname) {
 557           register int compare = strcmp(name, iname);
 558           if (compare == 0) {
 559             return iter->types[i];
 560           } else if (compare < 0) {
 561             if (i) {
 562               r = i - 1;
 563             } else {
 564               break;
 565             }
 566           } else if (compare > 0) {
 567             l = i + 1;
 568           }
 569         } else {
 570           break; /* should never happen */
 571         }
 572       } while (l <= r);
 573     }
 574     iter = iter->next;
 575   } while (iter != end);
 576   return 0;
 577 }
 578
 579 /*
 580   Search for a swig_type_info structure for either a mangled name or a human readable name.
 581   It first searches the mangled names of the types, which is a O(log #types)
 582   If a type is not found it then searches the human readable names, which is O(#types).
 583
 584   We start searching at module start, and finish searching when start == end.
 585   Note: if start == end at the beginning of the function, we go all the way around
 586   the circular list.
 587 */
 588 SWIGRUNTIME swig_type_info *
 589 SWIG_TypeQueryModule(swig_module_info *start,
 590                      swig_module_info *end,
 591                      const char *name) {
 592   /* STEP 1: Search the name field using binary search */
 593   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 594   if (ret) {
 595     return ret;
 596   } else {
 597     /* STEP 2: If the type hasn't been found, do a complete search
 598        of the str field (the human readable name) */
 599     swig_module_info *iter = start;
 600     do {
 601       register size_t i = 0;
 602       for (; i < iter->size; ++i) {
 603         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 604           return iter->types[i];
 605       }
 606       iter = iter->next;
 607     } while (iter != end);
 608   }
 609
 610   /* neither found a match */
 611   return 0;
 612 }
 613
 614 /*
 615    Pack binary data into a string
 616 */
 617 SWIGRUNTIME char *
 618 SWIG_PackData(char *c, void *ptr, size_t sz) {
 619   static const char hex[17] = "0123456789abcdef";
 620   register const unsigned char *u = (unsigned char *) ptr;
 621   register const unsigned char *eu =  u + sz;
 622   for (; u != eu; ++u) {
 623     register unsigned char uu = *u;
 624     *(c++) = hex[(uu & 0xf0) >> 4];
 625     *(c++) = hex[uu & 0xf];
 626   }
 627   return c;
 628 }
 629
 630 /*
 631    Unpack binary data from a string
 632 */
 633 SWIGRUNTIME const char *
 634 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 635   register unsigned char *u = (unsigned char *) ptr;
 636   register const unsigned char *eu = u + sz;
 637   for (; u != eu; ++u) {
 638     register char d = *(c++);
 639     register unsigned char uu;
 640     if ((d >= '0') && (d <= '9'))
 641       uu = ((d - '0') << 4);
 642     else if ((d >= 'a') && (d <= 'f'))
 643       uu = ((d - ('a'-10)) << 4);
 644     else
 645       return (char *) 0;
 646     d = *(c++);
 647     if ((d >= '0') && (d <= '9'))
 648       uu |= (d - '0');
 649     else if ((d >= 'a') && (d <= 'f'))
 650       uu |= (d - ('a'-10));
 651     else
 652       return (char *) 0;
 653     *u = uu;
 654   }
 655   return c;
 656 }
 657
 658 /*
 659    Pack 'void *' into a string buffer.
 660 */
 661 SWIGRUNTIME char *
 662 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 663   char *r = buff;
 664   if ((2*sizeof(void *) + 2) > bsz) return 0;
 665   *(r++) = '_';
 666   r = SWIG_PackData(r,&ptr,sizeof(void *));
 667   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 668   strcpy(r,name);
 669   return buff;
 670 }
 671
 672 SWIGRUNTIME const char *
 673 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 674   if (*c != '_') {
 675     if (strcmp(c,"NULL") == 0) {
 676       *ptr = (void *) 0;
 677       return name;
 678     } else {
 679       return 0;
 680     }
 681   }
 682   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 683 }
 684
 685 SWIGRUNTIME char *
 686 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 687   char *r = buff;
 688   size_t lname = (name ? strlen(name) : 0);
 689   if ((2*sz + 2 + lname) > bsz) return 0;
 690   *(r++) = '_';
 691   r = SWIG_PackData(r,ptr,sz);
 692   if (lname) {
 693     strncpy(r,name,lname+1);
 694   } else {
 695     *r = 0;
 696   }
 697   return buff;
 698 }
 699
 700 SWIGRUNTIME const char *
 701 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 702   if (*c != '_') {
 703     if (strcmp(c,"NULL") == 0) {
 704       memset(ptr,0,sz);
 705       return name;
 706     } else {
 707       return 0;
 708     }
 709   }
 710   return SWIG_UnpackData(++c,ptr,sz);
 711 }
 712
 713 #ifdef __cplusplus
 714 }
 715 #endif
 716
 717 /*  Errors in SWIG */
 718 #define  SWIG_UnknownError         -1
 719 #define  SWIG_IOError              -2
 720 #define  SWIG_RuntimeError         -3
 721 #define  SWIG_IndexError           -4
 722 #define  SWIG_TypeError            -5
 723 #define  SWIG_DivisionByZero       -6
 724 #define  SWIG_OverflowError        -7
 725 #define  SWIG_SyntaxError          -8
 726 #define  SWIG_ValueError           -9
 727 #define  SWIG_SystemError          -10
 728 #define  SWIG_AttributeError       -11
 729 #define  SWIG_MemoryError          -12
 730 #define  SWIG_NullReferenceError   -13
 731
 732
 733
 734
 735 /* Add PyOS_snprintf for old Pythons */
 736 #if PY_VERSION_HEX < 0x02020000
 737 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
 738 #  define PyOS_snprintf _snprintf
 739 # else
 740 #  define PyOS_snprintf snprintf
 741 # endif
 742 #endif
 743
 744 /* A crude PyString_FromFormat implementation for old Pythons */
 745 #if PY_VERSION_HEX < 0x02020000
 746
 747 #ifndef SWIG_PYBUFFER_SIZE
 748 # define SWIG_PYBUFFER_SIZE 1024
 749 #endif
 750
 751 static PyObject *
 752 PyString_FromFormat(const char *fmt, ...) {
 753   va_list ap;
 754   char buf[SWIG_PYBUFFER_SIZE * 2];
 755   int res;
 756   va_start(ap, fmt);
 757   res = vsnprintf(buf, sizeof(buf), fmt, ap);
 758   va_end(ap);
 759   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
 760 }
 761 #endif
 762
 763 /* Add PyObject_Del for old Pythons */
 764 #if PY_VERSION_HEX < 0x01060000
 765 # define PyObject_Del(op) PyMem_DEL((op))
 766 #endif
 767 #ifndef PyObject_DEL
 768 # define PyObject_DEL PyObject_Del
 769 #endif
 770
 771 /* A crude PyExc_StopIteration exception for old Pythons */
 772 #if PY_VERSION_HEX < 0x02020000
 773 # ifndef PyExc_StopIteration
 774 #  define PyExc_StopIteration PyExc_RuntimeError
 775 # endif
 776 # ifndef PyObject_GenericGetAttr
 777 #  define PyObject_GenericGetAttr 0
 778 # endif
 779 #endif
 780 /* Py_NotImplemented is defined in 2.1 and up. */
 781 #if PY_VERSION_HEX < 0x02010000
 782 # ifndef Py_NotImplemented
 783 #  define Py_NotImplemented PyExc_RuntimeError
 784 # endif
 785 #endif
 786
 787
 788 /* A crude PyString_AsStringAndSize implementation for old Pythons */
 789 #if PY_VERSION_HEX < 0x02010000
 790 # ifndef PyString_AsStringAndSize
 791 #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
 792 # endif
 793 #endif
 794
 795 /* PySequence_Size for old Pythons */
 796 #if PY_VERSION_HEX < 0x02000000
 797 # ifndef PySequence_Size
 798 #  define PySequence_Size PySequence_Length
 799 # endif
 800 #endif
 801
 802
 803 /* PyBool_FromLong for old Pythons */
 804 #if PY_VERSION_HEX < 0x02030000
 805 static
 806 PyObject *PyBool_FromLong(long ok)
 807 {
 808   PyObject *result = ok ? Py_True : Py_False;
 809   Py_INCREF(result);
 810   return result;
 811 }
 812 #endif
 813
 814 /* Py_ssize_t for old Pythons */
 815 /* This code is as recommended by: */
 816 /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
 817 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
 818 typedef int Py_ssize_t;
 819 # define PY_SSIZE_T_MAX INT_MAX
 820 # define PY_SSIZE_T_MIN INT_MIN
 821 #endif
 822
 823 /* -----------------------------------------------------------------------------
 824  * error manipulation
 825  * ----------------------------------------------------------------------------- */
 826
 827 SWIGRUNTIME PyObject*
 828 SWIG_Python_ErrorType(int code) {
 829   PyObject* type = 0;
 830   switch(code) {
 831   case SWIG_MemoryError:
 832     type = PyExc_MemoryError;
 833     break;
 834   case SWIG_IOError:
 835     type = PyExc_IOError;
 836     break;
 837   case SWIG_RuntimeError:
 838     type = PyExc_RuntimeError;
 839     break;
 840   case SWIG_IndexError:
 841     type = PyExc_IndexError;
 842     break;
 843   case SWIG_TypeError:
 844     type = PyExc_TypeError;
 845     break;
 846   case SWIG_DivisionByZero:
 847     type = PyExc_ZeroDivisionError;
 848     break;
 849   case SWIG_OverflowError:
 850     type = PyExc_OverflowError;
 851     break;
 852   case SWIG_SyntaxError:
 853     type = PyExc_SyntaxError;
 854     break;
 855   case SWIG_ValueError:
 856     type = PyExc_ValueError;
 857     break;
 858   case SWIG_SystemError:
 859     type = PyExc_SystemError;
 860     break;
 861   case SWIG_AttributeError:
 862     type = PyExc_AttributeError;
 863     break;
 864   default:
 865     type = PyExc_RuntimeError;
 866   }
 867   return type;
 868 }
 869
 870
 871 SWIGRUNTIME void
 872 SWIG_Python_AddErrorMsg(const char* mesg)
 873 {
 874   PyObject *type = 0;
 875   PyObject *value = 0;
 876   PyObject *traceback = 0;
 877
 878   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
 879   if (value) {
 880     PyObject *old_str = PyObject_Str(value);
 881     PyErr_Clear();
 882     Py_XINCREF(type);
 883     PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
 884     Py_DECREF(old_str);
 885     Py_DECREF(value);
 886   } else {
 887     PyErr_SetString(PyExc_RuntimeError, mesg);
 888   }
 889 }
 890
 891
 892
 893 #if defined(SWIG_PYTHON_NO_THREADS)
 894 #  if defined(SWIG_PYTHON_THREADS)
 895 #    undef SWIG_PYTHON_THREADS
 896 #  endif
 897 #endif
 898 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
 899 #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
 900 #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
 901 #      define SWIG_PYTHON_USE_GIL
 902 #    endif
 903 #  endif
 904 #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
 905 #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
 906 #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads()
 907 #    endif
 908 #    ifdef __cplusplus /* C++ code */
 909        class SWIG_Python_Thread_Block {
 910          bool status;
 911          PyGILState_STATE state;
 912        public:
 913          void end() { if (status) { PyGILState_Release(state); status = false;} }
 914          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
 915          ~SWIG_Python_Thread_Block() { end(); }
 916        };
 917        class SWIG_Python_Thread_Allow {
 918          bool status;
 919          PyThreadState *save;
 920        public:
 921          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
 922          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
 923          ~SWIG_Python_Thread_Allow() { end(); }
 924        };
 925 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
 926 #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
 927 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
 928 #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
 929 #    else /* C code */
 930 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
 931 #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
 932 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
 933 #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
 934 #    endif
 935 #  else /* Old thread way, not implemented, user must provide it */
 936 #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
 937 #      define SWIG_PYTHON_INITIALIZE_THREADS
 938 #    endif
 939 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
 940 #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 941 #    endif
 942 #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
 943 #      define SWIG_PYTHON_THREAD_END_BLOCK
 944 #    endif
 945 #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
 946 #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 947 #    endif
 948 #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
 949 #      define SWIG_PYTHON_THREAD_END_ALLOW
 950 #    endif
 951 #  endif
 952 #else /* No thread support */
 953 #  define SWIG_PYTHON_INITIALIZE_THREADS
 954 #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
 955 #  define SWIG_PYTHON_THREAD_END_BLOCK
 956 #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
 957 #  define SWIG_PYTHON_THREAD_END_ALLOW
 958 #endif
 959
 960 /* -----------------------------------------------------------------------------
 961  * Python API portion that goes into the runtime
 962  * ----------------------------------------------------------------------------- */
 963
 964 #ifdef __cplusplus
 965 extern "C" {
 966 #if 0
 967 } /* cc-mode */
 968 #endif
 969 #endif
 970
 971 /* -----------------------------------------------------------------------------
 972  * Constant declarations
 973  * ----------------------------------------------------------------------------- */
 974
 975 /* Constant Types */
 976 #define SWIG_PY_POINTER 4
 977 #define SWIG_PY_BINARY  5
 978
 979 /* Constant information structure */
 980 typedef struct swig_const_info {
 981   int type;
 982   char *name;
 983   long lvalue;
 984   double dvalue;
 985   void   *pvalue;
 986   swig_type_info **ptype;
 987 } swig_const_info;
 988
 989 #ifdef __cplusplus
 990 #if 0
 991 { /* cc-mode */
 992 #endif
 993 }
 994 #endif
 995
 996
 997 /* -----------------------------------------------------------------------------
 998  * See the LICENSE file for information on copyright, usage and redistribution
 999  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1000  *
1001  * pyrun.swg
1002  *
1003  * This file contains the runtime support for Python modules
1004  * and includes code for managing global variables and pointer
1005  * type checking.
1006  *
1007  * ----------------------------------------------------------------------------- */
1008
1009 /* Common SWIG API */
1010
1011 /* for raw pointers */
1012 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1013 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1014 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1015 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(ptr, type, flags)
1016 #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty)
1017 #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
1018 #define swig_owntype                                    int
1019
1020 /* for raw packed data */
1021 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1022 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1023
1024 /* for class or struct pointers */
1025 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
1026 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
1027
1028 /* for C or C++ function pointers */
1029 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1030 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(ptr, type, 0)
1031
1032 /* for C++ member pointers, ie, member methods */
1033 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1034 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
1035
1036
1037 /* Runtime API */
1038
1039 #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule()
1040 #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
1041 #define SWIG_NewClientData(obj)                         PySwigClientData_New(obj)
1042
1043 #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj
1044 #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg
1045 #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)
1046 #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1047 #define SWIG_fail                                       goto fail
1048
1049
1050 /* Runtime API implementation */
1051
1052 /* Error manipulation */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1056   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1057   PyErr_SetObject(errtype, obj);
1058   Py_DECREF(obj);
1059   SWIG_PYTHON_THREAD_END_BLOCK;
1060 }
1061
1062 SWIGINTERN void
1063 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1064   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1065   PyErr_SetString(errtype, (char *) msg);
1066   SWIG_PYTHON_THREAD_END_BLOCK;
1067 }
1068
1069 #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1070
1071 /* Set a constant value */
1072
1073 SWIGINTERN void
1074 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1075   PyDict_SetItemString(d, (char*) name, obj);
1076   Py_DECREF(obj);
1077 }
1078
1079 /* Append a value to the result obj */
1080
1081 SWIGINTERN PyObject*
1082 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1083 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1084   if (!result) {
1085     result = obj;
1086   } else if (result == Py_None) {
1087     Py_DECREF(result);
1088     result = obj;
1089   } else {
1090     if (!PyList_Check(result)) {
1091       PyObject *o2 = result;
1092       result = PyList_New(1);
1093       PyList_SetItem(result, 0, o2);
1094     }
1095     PyList_Append(result,obj);
1096     Py_DECREF(obj);
1097   }
1098   return result;
1099 #else
1100   PyObject*   o2;
1101   PyObject*   o3;
1102   if (!result) {
1103     result = obj;
1104   } else if (result == Py_None) {
1105     Py_DECREF(result);
1106     result = obj;
1107   } else {
1108     if (!PyTuple_Check(result)) {
1109       o2 = result;
1110       result = PyTuple_New(1);
1111       PyTuple_SET_ITEM(result, 0, o2);
1112     }
1113     o3 = PyTuple_New(1);
1114     PyTuple_SET_ITEM(o3, 0, obj);
1115     o2 = result;
1116     result = PySequence_Concat(o2, o3);
1117     Py_DECREF(o2);
1118     Py_DECREF(o3);
1119   }
1120   return result;
1121 #endif
1122 }
1123
1124 /* Unpack the argument tuple */
1125
1126 SWIGINTERN int
1127 SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1128 {
1129   if (!args) {
1130     if (!min && !max) {
1131       return 1;
1132     } else {
1133       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1134                    name, (min == max ? "" : "at least "), (int)min);
1135       return 0;
1136     }
1137   }
1138   if (!PyTuple_Check(args)) {
1139     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1140     return 0;
1141   } else {
1142     register Py_ssize_t l = PyTuple_GET_SIZE(args);
1143     if (l < min) {
1144       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1145                    name, (min == max ? "" : "at least "), (int)min, (int)l);
1146       return 0;
1147     } else if (l > max) {
1148       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1149                    name, (min == max ? "" : "at most "), (int)max, (int)l);
1150       return 0;
1151     } else {
1152       register int i;
1153       for (i = 0; i < l; ++i) {
1154         objs[i] = PyTuple_GET_ITEM(args, i);
1155       }
1156       for (; l < max; ++l) {
1157         objs[l] = 0;
1158       }
1159       return i + 1;
1160     }
1161   }
1162 }
1163
1164 /* A functor is a function object with one single object argument */
1165 #if PY_VERSION_HEX >= 0x02020000
1166 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
1167 #else
1168 #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
1169 #endif
1170
1171 /*
1172   Helper for static pointer initialization for both C and C++ code, for example
1173   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1174 */
1175 #ifdef __cplusplus
1176 #define SWIG_STATIC_POINTER(var)  var
1177 #else
1178 #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
1179 #endif
1180
1181 /* -----------------------------------------------------------------------------
1182  * Pointer declarations
1183  * ----------------------------------------------------------------------------- */
1184
1185 /* Flags for new pointer objects */
1186 #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
1187 #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1188
1189 #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
1190
1191 #ifdef __cplusplus
1192 extern "C" {
1193 #if 0
1194 } /* cc-mode */
1195 #endif
1196 #endif
1197
1198 /*  How to access Py_None */
1199 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1200 #  ifndef SWIG_PYTHON_NO_BUILD_NONE
1201 #    ifndef SWIG_PYTHON_BUILD_NONE
1202 #      define SWIG_PYTHON_BUILD_NONE
1203 #    endif
1204 #  endif
1205 #endif
1206
1207 #ifdef SWIG_PYTHON_BUILD_NONE
1208 #  ifdef Py_None
1209 #   undef Py_None
1210 #   define Py_None SWIG_Py_None()
1211 #  endif
1212 SWIGRUNTIMEINLINE PyObject *
1213 _SWIG_Py_None(void)
1214 {
1215   PyObject *none = Py_BuildValue((char*)"");
1216   Py_DECREF(none);
1217   return none;
1218 }
1219 SWIGRUNTIME PyObject *
1220 SWIG_Py_None(void)
1221 {
1222   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1223   return none;
1224 }
1225 #endif
1226
1227 /* The python void return value */
1228
1229 SWIGRUNTIMEINLINE PyObject *
1230 SWIG_Py_Void(void)
1231 {
1232   PyObject *none = Py_None;
1233   Py_INCREF(none);
1234   return none;
1235 }
1236
1237 /* PySwigClientData */
1238
1239 typedef struct {
1240   PyObject *klass;
1241   PyObject *newraw;
1242   PyObject *newargs;
1243   PyObject *destroy;
1244   int delargs;
1245   int implicitconv;
1246 } PySwigClientData;
1247
1248 SWIGRUNTIMEINLINE int
1249 SWIG_Python_CheckImplicit(swig_type_info *ty)
1250 {
1251   PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1252   return data ? data->implicitconv : 0;
1253 }
1254
1255 SWIGRUNTIMEINLINE PyObject *
1256 SWIG_Python_ExceptionType(swig_type_info *desc) {
1257   PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1258   PyObject *klass = data ? data->klass : 0;
1259   return (klass ? klass : PyExc_RuntimeError);
1260 }
1261
1262
1263 SWIGRUNTIME PySwigClientData *
1264 PySwigClientData_New(PyObject* obj)
1265 {
1266   if (!obj) {
1267     return 0;
1268   } else {
1269     PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1270     /* the klass element */
1271     data->klass = obj;
1272     Py_INCREF(data->klass);
1273     /* the newraw method and newargs arguments used to create a new raw instance */
1274     if (PyClass_Check(obj)) {
1275       data->newraw = 0;
1276       data->newargs = obj;
1277       Py_INCREF(obj);
1278     } else {
1279 #if (PY_VERSION_HEX < 0x02020000)
1280       data->newraw = 0;
1281 #else
1282       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1283 #endif
1284       if (data->newraw) {
1285         Py_INCREF(data->newraw);
1286         data->newargs = PyTuple_New(1);
1287         PyTuple_SetItem(data->newargs, 0, obj);
1288       } else {
1289         data->newargs = obj;
1290       }
1291       Py_INCREF(data->newargs);
1292     }
1293     /* the destroy method, aka as the C++ delete method */
1294     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1295     if (PyErr_Occurred()) {
1296       PyErr_Clear();
1297       data->destroy = 0;
1298     }
1299     if (data->destroy) {
1300       int flags;
1301       Py_INCREF(data->destroy);
1302       flags = PyCFunction_GET_FLAGS(data->destroy);
1303 #ifdef METH_O
1304       data->delargs = !(flags & (METH_O));
1305 #else
1306       data->delargs = 0;
1307 #endif
1308     } else {
1309       data->delargs = 0;
1310     }
1311     data->implicitconv = 0;
1312     return data;
1313   }
1314 }
1315
1316 SWIGRUNTIME void
1317 PySwigClientData_Del(PySwigClientData* data)
1318 {
1319   Py_XDECREF(data->newraw);
1320   Py_XDECREF(data->newargs);
1321   Py_XDECREF(data->destroy);
1322 }
1323
1324 /* =============== PySwigObject =====================*/
1325
1326 typedef struct {
1327   PyObject_HEAD
1328   void *ptr;
1329   swig_type_info *ty;
1330   int own;
1331   PyObject *next;
1332 } PySwigObject;
1333
1334 SWIGRUNTIME PyObject *
1335 PySwigObject_long(PySwigObject *v)
1336 {
1337   return PyLong_FromVoidPtr(v->ptr);
1338 }
1339
1340 SWIGRUNTIME PyObject *
1341 PySwigObject_format(const char* fmt, PySwigObject *v)
1342 {
1343   PyObject *res = NULL;
1344   PyObject *args = PyTuple_New(1);
1345   if (args) {
1346     if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1347       PyObject *ofmt = PyString_FromString(fmt);
1348       if (ofmt) {
1349         res = PyString_Format(ofmt,args);
1350         Py_DECREF(ofmt);
1351       }
1352       Py_DECREF(args);
1353     }
1354   }
1355   return res;
1356 }
1357
1358 SWIGRUNTIME PyObject *
1359 PySwigObject_oct(PySwigObject *v)
1360 {
1361   return PySwigObject_format("%o",v);
1362 }
1363
1364 SWIGRUNTIME PyObject *
1365 PySwigObject_hex(PySwigObject *v)
1366 {
1367   return PySwigObject_format("%x",v);
1368 }
1369
1370 SWIGRUNTIME PyObject *
1371 #ifdef METH_NOARGS
1372 PySwigObject_repr(PySwigObject *v)
1373 #else
1374 PySwigObject_repr(PySwigObject *v, PyObject *args)
1375 #endif
1376 {
1377   const char *name = SWIG_TypePrettyName(v->ty);
1378   PyObject *hex = PySwigObject_hex(v);
1379   PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1380   Py_DECREF(hex);
1381   if (v->next) {
1382 #ifdef METH_NOARGS
1383     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1384 #else
1385     PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1386 #endif
1387     PyString_ConcatAndDel(&repr,nrep);
1388   }
1389   return repr;
1390 }
1391
1392 SWIGRUNTIME int
1393 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1394 {
1395 #ifdef METH_NOARGS
1396   PyObject *repr = PySwigObject_repr(v);
1397 #else
1398   PyObject *repr = PySwigObject_repr(v, NULL);
1399 #endif
1400   if (repr) {
1401     fputs(PyString_AsString(repr), fp);
1402     Py_DECREF(repr);
1403     return 0;
1404   } else {
1405     return 1;
1406   }
1407 }
1408
1409 SWIGRUNTIME PyObject *
1410 PySwigObject_str(PySwigObject *v)
1411 {
1412   char result[SWIG_BUFFER_SIZE];
1413   return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1414     PyString_FromString(result) : 0;
1415 }
1416
1417 SWIGRUNTIME int
1418 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1419 {
1420   void *i = v->ptr;
1421   void *j = w->ptr;
1422   return (i < j) ? -1 : ((i > j) ? 1 : 0);
1423 }
1424
1425 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1426
1427 SWIGRUNTIME PyTypeObject*
1428 PySwigObject_type(void) {
1429   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1430   return type;
1431 }
1432
1433 SWIGRUNTIMEINLINE int
1434 PySwigObject_Check(PyObject *op) {
1435   return ((op)->ob_type == PySwigObject_type())
1436     || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1437 }
1438
1439 SWIGRUNTIME PyObject *
1440 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1441
1442 SWIGRUNTIME void
1443 PySwigObject_dealloc(PyObject *v)
1444 {
1445   PySwigObject *sobj = (PySwigObject *) v;
1446   PyObject *next = sobj->next;
1447   if (sobj->own == SWIG_POINTER_OWN) {
1448     swig_type_info *ty = sobj->ty;
1449     PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1450     PyObject *destroy = data ? data->destroy : 0;
1451     if (destroy) {
1452       /* destroy is always a VARARGS method */
1453       PyObject *res;
1454       if (data->delargs) {
1455         /* we need to create a temporal object to carry the destroy operation */
1456         PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1457         res = SWIG_Python_CallFunctor(destroy, tmp);
1458         Py_DECREF(tmp);
1459       } else {
1460         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1461         PyObject *mself = PyCFunction_GET_SELF(destroy);
1462         res = ((*meth)(mself, v));
1463       }
1464       Py_XDECREF(res);
1465     }
1466 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1467     else {
1468       const char *name = SWIG_TypePrettyName(ty);
1469       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1470     }
1471 #endif
1472   }
1473   Py_XDECREF(next);
1474   PyObject_DEL(v);
1475 }
1476
1477 SWIGRUNTIME PyObject*
1478 PySwigObject_append(PyObject* v, PyObject* next)
1479 {
1480   PySwigObject *sobj = (PySwigObject *) v;
1481 #ifndef METH_O
1482   PyObject *tmp = 0;
1483   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1484   next = tmp;
1485 #endif
1486   if (!PySwigObject_Check(next)) {
1487     return NULL;
1488   }
1489   sobj->next = next;
1490   Py_INCREF(next);
1491   return SWIG_Py_Void();
1492 }
1493
1494 SWIGRUNTIME PyObject*
1495 #ifdef METH_NOARGS
1496 PySwigObject_next(PyObject* v)
1497 #else
1498 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1499 #endif
1500 {
1501   PySwigObject *sobj = (PySwigObject *) v;
1502   if (sobj->next) {
1503     Py_INCREF(sobj->next);
1504     return sobj->next;
1505   } else {
1506     return SWIG_Py_Void();
1507   }
1508 }
1509
1510 SWIGINTERN PyObject*
1511 #ifdef METH_NOARGS
1512 PySwigObject_disown(PyObject *v)
1513 #else
1514 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1515 #endif
1516 {
1517   PySwigObject *sobj = (PySwigObject *)v;
1518   sobj->own = 0;
1519   return SWIG_Py_Void();
1520 }
1521
1522 SWIGINTERN PyObject*
1523 #ifdef METH_NOARGS
1524 PySwigObject_acquire(PyObject *v)
1525 #else
1526 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1527 #endif
1528 {
1529   PySwigObject *sobj = (PySwigObject *)v;
1530   sobj->own = SWIG_POINTER_OWN;
1531   return SWIG_Py_Void();
1532 }
1533
1534 SWIGINTERN PyObject*
1535 PySwigObject_own(PyObject *v, PyObject *args)
1536 {
1537   PyObject *val = 0;
1538 #if (PY_VERSION_HEX < 0x02020000)
1539   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1540 #else
1541   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1542 #endif
1543     {
1544       return NULL;
1545     }
1546   else
1547     {
1548       PySwigObject *sobj = (PySwigObject *)v;
1549       PyObject *obj = PyBool_FromLong(sobj->own);
1550       if (val) {
1551 #ifdef METH_NOARGS
1552         if (PyObject_IsTrue(val)) {
1553           PySwigObject_acquire(v);
1554         } else {
1555           PySwigObject_disown(v);
1556         }
1557 #else
1558         if (PyObject_IsTrue(val)) {
1559           PySwigObject_acquire(v,args);
1560         } else {
1561           PySwigObject_disown(v,args);
1562         }
1563 #endif
1564       }
1565       return obj;
1566     }
1567 }
1568
1569 #ifdef METH_O
1570 static PyMethodDef
1571 swigobject_methods[] = {
1572   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
1573   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS,  (char *)"aquires ownership of the pointer"},
1574   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1575   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_O,       (char *)"appends another 'this' object"},
1576   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
1577   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
1578   {0, 0, 0, 0}
1579 };
1580 #else
1581 static PyMethodDef
1582 swigobject_methods[] = {
1583   {(char *)"disown",  (PyCFunction)PySwigObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
1584   {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS,  (char *)"aquires ownership of the pointer"},
1585   {(char *)"own",     (PyCFunction)PySwigObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
1586   {(char *)"append",  (PyCFunction)PySwigObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
1587   {(char *)"next",    (PyCFunction)PySwigObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
1588   {(char *)"__repr__",(PyCFunction)PySwigObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
1589   {0, 0, 0, 0}
1590 };
1591 #endif
1592
1593 #if PY_VERSION_HEX < 0x02020000
1594 SWIGINTERN PyObject *
1595 PySwigObject_getattr(PySwigObject *sobj,char *name)
1596 {
1597   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1598 }
1599 #endif
1600
1601 SWIGRUNTIME PyTypeObject*
1602 _PySwigObject_type(void) {
1603   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1604
1605   static PyNumberMethods PySwigObject_as_number = {
1606     (binaryfunc)0, /*nb_add*/
1607     (binaryfunc)0, /*nb_subtract*/
1608     (binaryfunc)0, /*nb_multiply*/
1609     (binaryfunc)0, /*nb_divide*/
1610     (binaryfunc)0, /*nb_remainder*/
1611     (binaryfunc)0, /*nb_divmod*/
1612     (ternaryfunc)0,/*nb_power*/
1613     (unaryfunc)0,  /*nb_negative*/
1614     (unaryfunc)0,  /*nb_positive*/
1615     (unaryfunc)0,  /*nb_absolute*/
1616     (inquiry)0,    /*nb_nonzero*/
1617     0,             /*nb_invert*/
1618     0,             /*nb_lshift*/
1619     0,             /*nb_rshift*/
1620     0,             /*nb_and*/
1621     0,             /*nb_xor*/
1622     0,             /*nb_or*/
1623     (coercion)0,   /*nb_coerce*/
1624     (unaryfunc)PySwigObject_long, /*nb_int*/
1625     (unaryfunc)PySwigObject_long, /*nb_long*/
1626     (unaryfunc)0,                 /*nb_float*/
1627     (unaryfunc)PySwigObject_oct,  /*nb_oct*/
1628     (unaryfunc)PySwigObject_hex,  /*nb_hex*/
1629 #if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1630     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1631 #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1632     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1633 #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1634     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1635 #endif
1636   };
1637
1638   static PyTypeObject pyswigobject_type;
1639   static int type_init = 0;
1640   if (!type_init) {
1641     const PyTypeObject tmp
1642       = {
1643         PyObject_HEAD_INIT(NULL)
1644         0,                                  /* ob_size */
1645         (char *)"PySwigObject",             /* tp_name */
1646         sizeof(PySwigObject),               /* tp_basicsize */
1647         0,                                  /* tp_itemsize */
1648         (destructor)PySwigObject_dealloc,   /* tp_dealloc */
1649         (printfunc)PySwigObject_print,      /* tp_print */
1650 #if PY_VERSION_HEX < 0x02020000
1651         (getattrfunc)PySwigObject_getattr,  /* tp_getattr */
1652 #else
1653         (getattrfunc)0,                     /* tp_getattr */
1654 #endif
1655         (setattrfunc)0,                     /* tp_setattr */
1656         (cmpfunc)PySwigObject_compare,      /* tp_compare */
1657         (reprfunc)PySwigObject_repr,        /* tp_repr */
1658         &PySwigObject_as_number,            /* tp_as_number */
1659         0,                                  /* tp_as_sequence */
1660         0,                                  /* tp_as_mapping */
1661         (hashfunc)0,                        /* tp_hash */
1662         (ternaryfunc)0,                     /* tp_call */
1663         (reprfunc)PySwigObject_str,         /* tp_str */
1664         PyObject_GenericGetAttr,            /* tp_getattro */
1665         0,                                  /* tp_setattro */
1666         0,                                  /* tp_as_buffer */
1667         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1668         swigobject_doc,                     /* tp_doc */
1669         0,                                  /* tp_traverse */
1670         0,                                  /* tp_clear */
1671         0,                                  /* tp_richcompare */
1672         0,                                  /* tp_weaklistoffset */
1673 #if PY_VERSION_HEX >= 0x02020000
1674         0,                                  /* tp_iter */
1675         0,                                  /* tp_iternext */
1676         swigobject_methods,                 /* tp_methods */
1677         0,                                  /* tp_members */
1678         0,                                  /* tp_getset */
1679         0,                                  /* tp_base */
1680         0,                                  /* tp_dict */
1681         0,                                  /* tp_descr_get */
1682         0,                                  /* tp_descr_set */
1683         0,                                  /* tp_dictoffset */
1684         0,                                  /* tp_init */
1685         0,                                  /* tp_alloc */
1686         0,                                  /* tp_new */
1687         0,                                  /* tp_free */
1688         0,                                  /* tp_is_gc */
1689         0,                                  /* tp_bases */
1690         0,                                  /* tp_mro */
1691         0,                                  /* tp_cache */
1692         0,                                  /* tp_subclasses */
1693         0,                                  /* tp_weaklist */
1694 #endif
1695 #if PY_VERSION_HEX >= 0x02030000
1696         0,                                  /* tp_del */
1697 #endif
1698 #ifdef COUNT_ALLOCS
1699         0,0,0,0                             /* tp_alloc -> tp_next */
1700 #endif
1701       };
1702     pyswigobject_type = tmp;
1703     pyswigobject_type.ob_type = &PyType_Type;
1704     type_init = 1;
1705   }
1706   return &pyswigobject_type;
1707 }
1708
1709 SWIGRUNTIME PyObject *
1710 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1711 {
1712   PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1713   if (sobj) {
1714     sobj->ptr  = ptr;
1715     sobj->ty   = ty;
1716     sobj->own  = own;
1717     sobj->next = 0;
1718   }
1719   return (PyObject *)sobj;
1720 }
1721
1722 /* -----------------------------------------------------------------------------
1723  * Implements a simple Swig Packed type, and use it instead of string
1724  * ----------------------------------------------------------------------------- */
1725
1726 typedef struct {
1727   PyObject_HEAD
1728   void *pack;
1729   swig_type_info *ty;
1730   size_t size;
1731 } PySwigPacked;
1732
1733 SWIGRUNTIME int
1734 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1735 {
1736   char result[SWIG_BUFFER_SIZE];
1737   fputs("<Swig Packed ", fp);
1738   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1739     fputs("at ", fp);
1740     fputs(result, fp);
1741   }
1742   fputs(v->ty->name,fp);
1743   fputs(">", fp);
1744   return 0;
1745 }
1746
1747 SWIGRUNTIME PyObject *
1748 PySwigPacked_repr(PySwigPacked *v)
1749 {
1750   char result[SWIG_BUFFER_SIZE];
1751   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1752     return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1753   } else {
1754     return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1755   }
1756 }
1757
1758 SWIGRUNTIME PyObject *
1759 PySwigPacked_str(PySwigPacked *v)
1760 {
1761   char result[SWIG_BUFFER_SIZE];
1762   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1763     return PyString_FromFormat("%s%s", result, v->ty->name);
1764   } else {
1765     return PyString_FromString(v->ty->name);
1766   }
1767 }
1768
1769 SWIGRUNTIME int
1770 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1771 {
1772   size_t i = v->size;
1773   size_t j = w->size;
1774   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1775   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1776 }
1777
1778 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1779
1780 SWIGRUNTIME PyTypeObject*
1781 PySwigPacked_type(void) {
1782   static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1783   return type;
1784 }
1785
1786 SWIGRUNTIMEINLINE int
1787 PySwigPacked_Check(PyObject *op) {
1788   return ((op)->ob_type == _PySwigPacked_type())
1789     || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1790 }
1791
1792 SWIGRUNTIME void
1793 PySwigPacked_dealloc(PyObject *v)
1794 {
1795   if (PySwigPacked_Check(v)) {
1796     PySwigPacked *sobj = (PySwigPacked *) v;
1797     free(sobj->pack);
1798   }
1799   PyObject_DEL(v);
1800 }
1801
1802 SWIGRUNTIME PyTypeObject*
1803 _PySwigPacked_type(void) {
1804   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1805   static PyTypeObject pyswigpacked_type;
1806   static int type_init = 0;
1807   if (!type_init) {
1808     const PyTypeObject tmp
1809       = {
1810         PyObject_HEAD_INIT(NULL)
1811         0,                                  /* ob_size */
1812         (char *)"PySwigPacked",             /* tp_name */
1813         sizeof(PySwigPacked),               /* tp_basicsize */
1814         0,                                  /* tp_itemsize */
1815         (destructor)PySwigPacked_dealloc,   /* tp_dealloc */
1816         (printfunc)PySwigPacked_print,      /* tp_print */
1817         (getattrfunc)0,                     /* tp_getattr */
1818         (setattrfunc)0,                     /* tp_setattr */
1819         (cmpfunc)PySwigPacked_compare,      /* tp_compare */
1820         (reprfunc)PySwigPacked_repr,        /* tp_repr */
1821         0,                                  /* tp_as_number */
1822         0,                                  /* tp_as_sequence */
1823         0,                                  /* tp_as_mapping */
1824         (hashfunc)0,                        /* tp_hash */
1825         (ternaryfunc)0,                     /* tp_call */
1826         (reprfunc)PySwigPacked_str,         /* tp_str */
1827         PyObject_GenericGetAttr,            /* tp_getattro */
1828         0,                                  /* tp_setattro */
1829         0,                                  /* tp_as_buffer */
1830         Py_TPFLAGS_DEFAULT,                 /* tp_flags */
1831         swigpacked_doc,                     /* tp_doc */
1832         0,                                  /* tp_traverse */
1833         0,                                  /* tp_clear */
1834         0,                                  /* tp_richcompare */
1835         0,                                  /* tp_weaklistoffset */
1836 #if PY_VERSION_HEX >= 0x02020000
1837         0,                                  /* tp_iter */
1838         0,                                  /* tp_iternext */
1839         0,                                  /* tp_methods */
1840         0,                                  /* tp_members */
1841         0,                                  /* tp_getset */
1842         0,                                  /* tp_base */
1843         0,                                  /* tp_dict */
1844         0,                                  /* tp_descr_get */
1845         0,                                  /* tp_descr_set */
1846         0,                                  /* tp_dictoffset */
1847         0,                                  /* tp_init */
1848         0,                                  /* tp_alloc */
1849         0,                                  /* tp_new */
1850         0,                                  /* tp_free */
1851         0,                                  /* tp_is_gc */
1852         0,                                  /* tp_bases */
1853         0,                                  /* tp_mro */
1854         0,                                  /* tp_cache */
1855         0,                                  /* tp_subclasses */
1856         0,                                  /* tp_weaklist */
1857 #endif
1858 #if PY_VERSION_HEX >= 0x02030000
1859         0,                                  /* tp_del */
1860 #endif
1861 #ifdef COUNT_ALLOCS
1862         0,0,0,0                             /* tp_alloc -> tp_next */
1863 #endif
1864       };
1865     pyswigpacked_type = tmp;
1866     pyswigpacked_type.ob_type = &PyType_Type;
1867     type_init = 1;
1868   }
1869   return &pyswigpacked_type;
1870 }
1871
1872 SWIGRUNTIME PyObject *
1873 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1874 {
1875   PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1876   if (sobj) {
1877     void *pack = malloc(size);
1878     if (pack) {
1879       memcpy(pack, ptr, size);
1880       sobj->pack = pack;
1881       sobj->ty   = ty;
1882       sobj->size = size;
1883     } else {
1884       PyObject_DEL((PyObject *) sobj);
1885       sobj = 0;
1886     }
1887   }
1888   return (PyObject *) sobj;
1889 }
1890
1891 SWIGRUNTIME swig_type_info *
1892 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1893 {
1894   if (PySwigPacked_Check(obj)) {
1895     PySwigPacked *sobj = (PySwigPacked *)obj;
1896     if (sobj->size != size) return 0;
1897     memcpy(ptr, sobj->pack, size);
1898     return sobj->ty;
1899   } else {
1900     return 0;
1901   }
1902 }
1903
1904 /* -----------------------------------------------------------------------------
1905  * pointers/data manipulation
1906  * ----------------------------------------------------------------------------- */
1907
1908 SWIGRUNTIMEINLINE PyObject *
1909 _SWIG_This(void)
1910 {
1911   return PyString_FromString("this");
1912 }
1913
1914 SWIGRUNTIME PyObject *
1915 SWIG_This(void)
1916 {
1917   static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1918   return swig_this;
1919 }
1920
1921 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1922
1923 SWIGRUNTIME PySwigObject *
1924 SWIG_Python_GetSwigThis(PyObject *pyobj)
1925 {
1926   if (PySwigObject_Check(pyobj)) {
1927     return (PySwigObject *) pyobj;
1928   } else {
1929     PyObject *obj = 0;
1930 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1931     if (PyInstance_Check(pyobj)) {
1932       obj = _PyInstance_Lookup(pyobj, SWIG_This());
1933     } else {
1934       PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1935       if (dictptr != NULL) {
1936         PyObject *dict = *dictptr;
1937         obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1938       } else {
1939 #ifdef PyWeakref_CheckProxy
1940         if (PyWeakref_CheckProxy(pyobj)) {
1941           PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1942           return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1943         }
1944 #endif
1945         obj = PyObject_GetAttr(pyobj,SWIG_This());
1946         if (obj) {
1947           Py_DECREF(obj);
1948         } else {
1949           if (PyErr_Occurred()) PyErr_Clear();
1950           return 0;
1951         }
1952       }
1953     }
1954 #else
1955     obj = PyObject_GetAttr(pyobj,SWIG_This());
1956     if (obj) {
1957       Py_DECREF(obj);
1958     } else {
1959       if (PyErr_Occurred()) PyErr_Clear();
1960       return 0;
1961     }
1962 #endif
1963     if (obj && !PySwigObject_Check(obj)) {
1964       /* a PyObject is called 'this', try to get the 'real this'
1965          PySwigObject from it */
1966       return SWIG_Python_GetSwigThis(obj);
1967     }
1968     return (PySwigObject *)obj;
1969   }
1970 }
1971
1972 /* Acquire a pointer value */
1973
1974 SWIGRUNTIME int
1975 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1976   if (own == SWIG_POINTER_OWN) {
1977     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1978     if (sobj) {
1979       int oldown = sobj->own;
1980       sobj->own = own;
1981       return oldown;
1982     }
1983   }
1984   return 0;
1985 }
1986
1987 /* Convert a pointer value */
1988
1989 SWIGRUNTIME int
1990 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1991   if (!obj) return SWIG_ERROR;
1992   if (obj == Py_None) {
1993     if (ptr) *ptr = 0;
1994     return SWIG_OK;
1995   } else {
1996     PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1997     if (own)
1998       *own = 0;
1999     while (sobj) {
2000       void *vptr = sobj->ptr;
2001       if (ty) {
2002         swig_type_info *to = sobj->ty;
2003         if (to == ty) {
2004           /* no type cast needed */
2005           if (ptr) *ptr = vptr;
2006           break;
2007         } else {
2008           swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2009           if (!tc) {
2010             sobj = (PySwigObject *)sobj->next;
2011           } else {
2012             if (ptr) {
2013               int newmemory = 0;
2014               *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2015               if (newmemory == SWIG_CAST_NEW_MEMORY) {
2016                 assert(own);
2017                 if (own)
2018                   *own = *own | SWIG_CAST_NEW_MEMORY;
2019               }
2020             }
2021             break;
2022           }
2023         }
2024       } else {
2025         if (ptr) *ptr = vptr;
2026         break;
2027       }
2028     }
2029     if (sobj) {
2030       if (own)
2031         *own = *own | sobj->own;
2032       if (flags & SWIG_POINTER_DISOWN) {
2033         sobj->own = 0;
2034       }
2035       return SWIG_OK;
2036     } else {
2037       int res = SWIG_ERROR;
2038       if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2039         PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2040         if (data && !data->implicitconv) {
2041           PyObject *klass = data->klass;
2042           if (klass) {
2043             PyObject *impconv;
2044             data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2045             impconv = SWIG_Python_CallFunctor(klass, obj);
2046             data->implicitconv = 0;
2047             if (PyErr_Occurred()) {
2048               PyErr_Clear();
2049               impconv = 0;
2050             }
2051             if (impconv) {
2052               PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2053               if (iobj) {
2054                 void *vptr;
2055                 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2056                 if (SWIG_IsOK(res)) {
2057                   if (ptr) {
2058                     *ptr = vptr;
2059                     /* transfer the ownership to 'ptr' */
2060                     iobj->own = 0;
2061                     res = SWIG_AddCast(res);
2062                     res = SWIG_AddNewMask(res);
2063                   } else {
2064                     res = SWIG_AddCast(res);
2065                   }
2066                 }
2067               }
2068               Py_DECREF(impconv);
2069             }
2070           }
2071         }
2072       }
2073       return res;
2074     }
2075   }
2076 }
2077
2078 /* Convert a function ptr value */
2079
2080 SWIGRUNTIME int
2081 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2082   if (!PyCFunction_Check(obj)) {
2083     return SWIG_ConvertPtr(obj, ptr, ty, 0);
2084   } else {
2085     void *vptr = 0;
2086
2087     /* here we get the method pointer for callbacks */
2088     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2089     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2090     if (desc) {
2091       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2092       if (!desc) return SWIG_ERROR;
2093     }
2094     if (ty) {
2095       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2096       if (tc) {
2097         int newmemory = 0;
2098         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2099         assert(!newmemory); /* newmemory handling not yet implemented */
2100       } else {
2101         return SWIG_ERROR;
2102       }
2103     } else {
2104       *ptr = vptr;
2105     }
2106     return SWIG_OK;
2107   }
2108 }
2109
2110 /* Convert a packed value value */
2111
2112 SWIGRUNTIME int
2113 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2114   swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2115   if (!to) return SWIG_ERROR;
2116   if (ty) {
2117     if (to != ty) {
2118       /* check type cast? */
2119       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2120       if (!tc) return SWIG_ERROR;
2121     }
2122   }
2123   return SWIG_OK;
2124 }
2125
2126 /* -----------------------------------------------------------------------------
2127  * Create a new pointer object
2128  * ----------------------------------------------------------------------------- */
2129
2130 /*
2131   Create a new instance object, whitout calling __init__, and set the
2132   'this' attribute.
2133 */
2134
2135 SWIGRUNTIME PyObject*
2136 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2137 {
2138 #if (PY_VERSION_HEX >= 0x02020000)
2139   PyObject *inst = 0;
2140   PyObject *newraw = data->newraw;
2141   if (newraw) {
2142     inst = PyObject_Call(newraw, data->newargs, NULL);
2143     if (inst) {
2144 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2145       PyObject **dictptr = _PyObject_GetDictPtr(inst);
2146       if (dictptr != NULL) {
2147         PyObject *dict = *dictptr;
2148         if (dict == NULL) {
2149           dict = PyDict_New();
2150           *dictptr = dict;
2151           PyDict_SetItem(dict, SWIG_This(), swig_this);
2152         }
2153       }
2154 #else
2155       PyObject *key = SWIG_This();
2156       PyObject_SetAttr(inst, key, swig_this);
2157 #endif
2158     }
2159   } else {
2160     PyObject *dict = PyDict_New();
2161     PyDict_SetItem(dict, SWIG_This(), swig_this);
2162     inst = PyInstance_NewRaw(data->newargs, dict);
2163     Py_DECREF(dict);
2164   }
2165   return inst;
2166 #else
2167 #if (PY_VERSION_HEX >= 0x02010000)
2168   PyObject *inst;
2169   PyObject *dict = PyDict_New();
2170   PyDict_SetItem(dict, SWIG_This(), swig_this);
2171   inst = PyInstance_NewRaw(data->newargs, dict);
2172   Py_DECREF(dict);
2173   return (PyObject *) inst;
2174 #else
2175   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2176   if (inst == NULL) {
2177     return NULL;
2178   }
2179   inst->in_class = (PyClassObject *)data->newargs;
2180   Py_INCREF(inst->in_class);
2181   inst->in_dict = PyDict_New();
2182   if (inst->in_dict == NULL) {
2183     Py_DECREF(inst);
2184     return NULL;
2185   }
2186 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2187   inst->in_weakreflist = NULL;
2188 #endif
2189 #ifdef Py_TPFLAGS_GC
2190   PyObject_GC_Init(inst);
2191 #endif
2192   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2193   return (PyObject *) inst;
2194 #endif
2195 #endif
2196 }
2197
2198 SWIGRUNTIME void
2199 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2200 {
2201  PyObject *dict;
2202 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2203  PyObject **dictptr = _PyObject_GetDictPtr(inst);
2204  if (dictptr != NULL) {
2205    dict = *dictptr;
2206    if (dict == NULL) {
2207      dict = PyDict_New();
2208      *dictptr = dict;
2209    }
2210    PyDict_SetItem(dict, SWIG_This(), swig_this);
2211    return;
2212  }
2213 #endif
2214  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2215  PyDict_SetItem(dict, SWIG_This(), swig_this);
2216  Py_DECREF(dict);
2217 }
2218
2219
2220 SWIGINTERN PyObject *
2221 SWIG_Python_InitShadowInstance(PyObject *args) {
2222   PyObject *obj[2];
2223   if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2224     return NULL;
2225   } else {
2226     PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2227     if (sthis) {
2228       PySwigObject_append((PyObject*) sthis, obj[1]);
2229     } else {
2230       SWIG_Python_SetSwigThis(obj[0], obj[1]);
2231     }
2232     return SWIG_Py_Void();
2233   }
2234 }
2235
2236 /* Create a new pointer object */
2237
2238 SWIGRUNTIME PyObject *
2239 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2240   if (!ptr) {
2241     return SWIG_Py_Void();
2242   } else {
2243     int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2244     PyObject *robj = PySwigObject_New(ptr, type, own);
2245     PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2246     if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2247       PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2248       if (inst) {
2249         Py_DECREF(robj);
2250         robj = inst;
2251       }
2252     }
2253     return robj;
2254   }
2255 }
2256
2257 /* Create a new packed object */
2258
2259 SWIGRUNTIMEINLINE PyObject *
2260 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2261   return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2262 }
2263
2264 /* -----------------------------------------------------------------------------*
2265  *  Get type list
2266  * -----------------------------------------------------------------------------*/
2267
2268 #ifdef SWIG_LINK_RUNTIME
2269 void *SWIG_ReturnGlobalTypeList(void *);
2270 #endif
2271
2272 SWIGRUNTIME swig_module_info *
2273 SWIG_Python_GetModule(void) {
2274   static void *type_pointer = (void *)0;
2275   /* first check if module already created */
2276   if (!type_pointer) {
2277 #ifdef SWIG_LINK_RUNTIME
2278     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2279 #else
2280     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2281                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2282     if (PyErr_Occurred()) {
2283       PyErr_Clear();
2284       type_pointer = (void *)0;
2285     }
2286 #endif
2287   }
2288   return (swig_module_info *) type_pointer;
2289 }
2290
2291 #if PY_MAJOR_VERSION < 2
2292 /* PyModule_AddObject function was introduced in Python 2.0.  The following function
2293    is copied out of Python/modsupport.c in python version 2.3.4 */
2294 SWIGINTERN int
2295 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2296 {
2297   PyObject *dict;
2298   if (!PyModule_Check(m)) {
2299     PyErr_SetString(PyExc_TypeError,
2300                     "PyModule_AddObject() needs module as first arg");
2301     return SWIG_ERROR;
2302   }
2303   if (!o) {
2304     PyErr_SetString(PyExc_TypeError,
2305                     "PyModule_AddObject() needs non-NULL value");
2306     return SWIG_ERROR;
2307   }
2308
2309   dict = PyModule_GetDict(m);
2310   if (dict == NULL) {
2311     /* Internal error -- modules must have a dict! */
2312     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2313                  PyModule_GetName(m));
2314     return SWIG_ERROR;
2315   }
2316   if (PyDict_SetItemString(dict, name, o))
2317     return SWIG_ERROR;
2318   Py_DECREF(o);
2319   return SWIG_OK;
2320 }
2321 #endif
2322
2323 SWIGRUNTIME void
2324 SWIG_Python_DestroyModule(void *vptr)
2325 {
2326   swig_module_info *swig_module = (swig_module_info *) vptr;
2327   swig_type_info **types = swig_module->types;
2328   size_t i;
2329   for (i =0; i < swig_module->size; ++i) {
2330     swig_type_info *ty = types[i];
2331     if (ty->owndata) {
2332       PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2333       if (data) PySwigClientData_Del(data);
2334     }
2335   }
2336   Py_DECREF(SWIG_This());
2337 }
2338
2339 SWIGRUNTIME void
2340 SWIG_Python_SetModule(swig_module_info *swig_module) {
2341   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2342
2343   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2344                                    swig_empty_runtime_method_table);
2345   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2346   if (pointer && module) {
2347     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2348   } else {
2349     Py_XDECREF(pointer);
2350   }
2351 }
2352
2353 /* The python cached type query */
2354 SWIGRUNTIME PyObject *
2355 SWIG_Python_TypeCache(void) {
2356   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2357   return cache;
2358 }
2359
2360 SWIGRUNTIME swig_type_info *
2361 SWIG_Python_TypeQuery(const char *type)
2362 {
2363   PyObject *cache = SWIG_Python_TypeCache();
2364   PyObject *key = PyString_FromString(type);
2365   PyObject *obj = PyDict_GetItem(cache, key);
2366   swig_type_info *descriptor;
2367   if (obj) {
2368     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2369   } else {
2370     swig_module_info *swig_module = SWIG_Python_GetModule();
2371     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2372     if (descriptor) {
2373       obj = PyCObject_FromVoidPtr(descriptor, NULL);
2374       PyDict_SetItem(cache, key, obj);
2375       Py_DECREF(obj);
2376     }
2377   }
2378   Py_DECREF(key);
2379   return descriptor;
2380 }
2381
2382 /*
2383    For backward compatibility only
2384 */
2385 #define SWIG_POINTER_EXCEPTION  0
2386 #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
2387 #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
2388
2389 SWIGRUNTIME int
2390 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2391 {
2392   if (PyErr_Occurred()) {
2393     PyObject *type = 0;
2394     PyObject *value = 0;
2395     PyObject *traceback = 0;
2396     PyErr_Fetch(&type, &value, &traceback);
2397     if (value) {
2398       PyObject *old_str = PyObject_Str(value);
2399       Py_XINCREF(type);
2400       PyErr_Clear();
2401       if (infront) {
2402         PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2403       } else {
2404         PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2405       }
2406       Py_DECREF(old_str);
2407     }
2408     return 1;
2409   } else {
2410     return 0;
2411   }
2412 }
2413
2414 SWIGRUNTIME int
2415 SWIG_Python_ArgFail(int argnum)
2416 {
2417   if (PyErr_Occurred()) {
2418     /* add information about failing argument */
2419     char mesg[256];
2420     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2421     return SWIG_Python_AddErrMesg(mesg, 1);
2422   } else {
2423     return 0;
2424   }
2425 }
2426
2427 SWIGRUNTIMEINLINE const char *
2428 PySwigObject_GetDesc(PyObject *self)
2429 {
2430   PySwigObject *v = (PySwigObject *)self;
2431   swig_type_info *ty = v ? v->ty : 0;
2432   return ty ? ty->str : (char*)"";
2433 }
2434
2435 SWIGRUNTIME void
2436 SWIG_Python_TypeError(const char *type, PyObject *obj)
2437 {
2438   if (type) {
2439 #if defined(SWIG_COBJECT_TYPES)
2440     if (obj && PySwigObject_Check(obj)) {
2441       const char *otype = (const char *) PySwigObject_GetDesc(obj);
2442       if (otype) {
2443         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2444                      type, otype);
2445         return;
2446       }
2447     } else
2448 #endif
2449     {
2450       const char *otype = (obj ? obj->ob_type->tp_name : 0);
2451       if (otype) {
2452         PyObject *str = PyObject_Str(obj);
2453         const char *cstr = str ? PyString_AsString(str) : 0;
2454         if (cstr) {
2455           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2456                        type, otype, cstr);
2457         } else {
2458           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2459                        type, otype);
2460         }
2461         Py_XDECREF(str);
2462         return;
2463       }
2464     }
2465     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2466   } else {
2467     PyErr_Format(PyExc_TypeError, "unexpected type is received");
2468   }
2469 }
2470
2471
2472 /* Convert a pointer value, signal an exception on a type mismatch */
2473 SWIGRUNTIME void *
2474 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2475   void *result;
2476   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2477     PyErr_Clear();
2478     if (flags & SWIG_POINTER_EXCEPTION) {
2479       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2480       SWIG_Python_ArgFail(argnum);
2481     }
2482   }
2483   return result;
2484 }
2485
2486
2487 #ifdef __cplusplus
2488 #if 0
2489 { /* cc-mode */
2490 #endif
2491 }
2492 #endif
2493
2494
2495
2496 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2497
2498 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2499
2500
2501
2502   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2503
2504
2505 /* -------- TYPES TABLE (BEGIN) -------- */
2506
2507 #define SWIGTYPE_p_allocator_type swig_types[0]
2508 #define SWIGTYPE_p_boost__shared_ptrT_gr_basic_block_t swig_types[1]
2509 #define SWIGTYPE_p_boost__shared_ptrT_gr_block_detail_t swig_types[2]
2510 #define SWIGTYPE_p_boost__shared_ptrT_gr_block_t swig_types[3]
2511 #define SWIGTYPE_p_boost__shared_ptrT_gr_buffer_reader_t swig_types[4]
2512 #define SWIGTYPE_p_boost__shared_ptrT_gr_buffer_t swig_types[5]
2513 #define SWIGTYPE_p_boost__shared_ptrT_gr_dispatcher_t swig_types[6]
2514 #define SWIGTYPE_p_boost__shared_ptrT_gr_hier_block2_t swig_types[7]
2515 #define SWIGTYPE_p_boost__shared_ptrT_gr_io_signature_t swig_types[8]
2516 #define SWIGTYPE_p_boost__shared_ptrT_gr_message_t swig_types[9]
2517 #define SWIGTYPE_p_boost__shared_ptrT_gr_msg_queue_t swig_types[10]
2518 #define SWIGTYPE_p_boost__shared_ptrT_gr_single_threaded_scheduler_t swig_types[11]
2519 #define SWIGTYPE_p_boost__shared_ptrT_gr_top_block_t swig_types[12]
2520 #define SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t swig_types[13]
2521 #define SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t swig_types[14]
2522 #define SWIGTYPE_p_char swig_types[15]
2523 #define SWIGTYPE_p_difference_type swig_types[16]
2524 #define SWIGTYPE_p_gr_basic_block swig_types[17]
2525 #define SWIGTYPE_p_gr_block swig_types[18]
2526 #define SWIGTYPE_p_gr_hier_block2 swig_types[19]
2527 #define SWIGTYPE_p_gr_sync_block swig_types[20]
2528 #define SWIGTYPE_p_gr_sync_decimator swig_types[21]
2529 #define SWIGTYPE_p_gr_sync_interpolator swig_types[22]
2530 #define SWIGTYPE_p_gr_top_block swig_types[23]
2531 #define SWIGTYPE_p_gruel__rt_status_t swig_types[24]
2532 #define SWIGTYPE_p_howto_square2_ff swig_types[25]
2533 #define SWIGTYPE_p_howto_square_ff swig_types[26]
2534 #define SWIGTYPE_p_size_type swig_types[27]
2535 #define SWIGTYPE_p_std__complexT_double_t swig_types[28]
2536 #define SWIGTYPE_p_std__complexT_float_t swig_types[29]
2537 #define SWIGTYPE_p_std__invalid_argument swig_types[30]
2538 #define SWIGTYPE_p_swig__PySwigIterator swig_types[31]
2539 #define SWIGTYPE_p_value_type swig_types[32]
2540 static swig_type_info *swig_types[34];
2541 static swig_module_info swig_module = {swig_types, 33, 0, 0, 0, 0};
2542 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2543 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2544
2545 /* -------- TYPES TABLE (END) -------- */
2546
2547 #if (PY_VERSION_HEX <= 0x02000000)
2548 # if !defined(SWIG_PYTHON_CLASSIC)
2549 #  error "This python version requires swig to be run with the '-classic' option"
2550 # endif
2551 #endif
2552 #if (PY_VERSION_HEX <= 0x02020000)
2553 # error "This python version requires swig to be run with the '-nomodern' option"
2554 #endif
2555 #if (PY_VERSION_HEX <= 0x02020000)
2556 # error "This python version requires swig to be run with the '-nomodernargs' option"
2557 #endif
2558
2559 /*-----------------------------------------------
2560               @(target):= _howto.so
2561   ------------------------------------------------*/
2562 #define SWIG_init    init_howto
2563
2564 #define SWIG_name    "_howto"
2565
2566 #define SWIGVERSION 0x010336
2567 #define SWIG_VERSION SWIGVERSION
2568
2569
2570 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2571 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2572
2573
2574 #include <stdexcept>
2575
2576
2577 namespace swig {
2578   class PyObject_ptr {
2579   protected:
2580     PyObject *_obj;
2581
2582   public:
2583     PyObject_ptr() :_obj(0)
2584     {
2585     }
2586
2587     PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2588     {
2589       Py_XINCREF(_obj);
2590     }
2591
2592     PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2593     {
2594       if (initial_ref) {
2595         Py_XINCREF(_obj);
2596       }
2597     }
2598
2599     PyObject_ptr & operator=(const PyObject_ptr& item)
2600     {
2601       Py_XINCREF(item._obj);
2602       Py_XDECREF(_obj);
2603       _obj = item._obj;
2604       return *this;
2605     }
2606
2607     ~PyObject_ptr()
2608     {
2609       Py_XDECREF(_obj);
2610     }
2611
2612     operator PyObject *() const
2613     {
2614       return _obj;
2615     }
2616
2617     PyObject *operator->() const
2618     {
2619       return _obj;
2620     }
2621   };
2622 }
2623
2624
2625 namespace swig {
2626   struct PyObject_var : PyObject_ptr {
2627     PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2628
2629     PyObject_var & operator = (PyObject* obj)
2630     {
2631       Py_XDECREF(_obj);
2632       _obj = obj;
2633       return *this;
2634     }
2635   };
2636 }
2637
2638
2639 #include "gnuradio_swig_bug_workaround.h"       // mandatory bug fix
2640 #include <gr_types.h>
2641 #include <stddef.h>             // size_t
2642
2643
2644 #include <stdexcept>
2645
2646
2647 #if defined(__GNUC__)
2648 #  if __GNUC__ == 2 && __GNUC_MINOR <= 96
2649 #     define SWIG_STD_NOMODERN_STL
2650 #  endif
2651 #endif
2652
2653
2654 #include <string>
2655 #include <stdexcept>
2656
2657
2658 #include <string>
2659
2660
2661 #include <iostream>
2662
2663
2664 namespace swig {
2665   struct stop_iteration {
2666   };
2667
2668   struct PySwigIterator {
2669   private:
2670     PyObject_ptr _seq;
2671
2672   protected:
2673     PySwigIterator(PyObject *seq) : _seq(seq)
2674     {
2675     }
2676
2677   public:
2678     virtual ~PySwigIterator() {}
2679
2680     // Access iterator method, required by Python
2681     virtual PyObject *value() const = 0;
2682
2683     // Forward iterator method, required by Python
2684     virtual PySwigIterator *incr(size_t n = 1) = 0;
2685
2686     // Backward iterator method, very common in C++, but not required in Python
2687     virtual PySwigIterator *decr(size_t /*n*/ = 1)
2688     {
2689       throw stop_iteration();
2690     }
2691
2692     // Random access iterator methods, but not required in Python
2693     virtual ptrdiff_t distance(const PySwigIterator &/*x*/) const
2694     {
2695       throw std::invalid_argument("operation not supported");
2696     }
2697
2698     virtual bool equal (const PySwigIterator &/*x*/) const
2699     {
2700       throw std::invalid_argument("operation not supported");
2701     }
2702
2703     // C++ common/needed methods
2704     virtual PySwigIterator *copy() const = 0;
2705
2706     PyObject *next()
2707     {
2708       SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
2709       PyObject *obj = value();
2710       incr();
2711       SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
2712       return obj;
2713     }
2714
2715     PyObject *previous()
2716     {
2717       SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
2718       decr();
2719       PyObject *obj = value();
2720       SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
2721       return obj;
2722     }
2723
2724     PySwigIterator *advance(ptrdiff_t n)
2725     {
2726       return  (n > 0) ?  incr(n) : decr(-n);
2727     }
2728
2729     bool operator == (const PySwigIterator& x)  const
2730     {
2731       return equal(x);
2732     }
2733
2734     bool operator != (const PySwigIterator& x) const
2735     {
2736       return ! operator==(x);
2737     }
2738
2739     PySwigIterator& operator += (ptrdiff_t n)
2740     {
2741       return *advance(n);
2742     }
2743
2744     PySwigIterator& operator -= (ptrdiff_t n)
2745     {
2746       return *advance(-n);
2747     }
2748
2749     PySwigIterator* operator + (ptrdiff_t n) const
2750     {
2751       return copy()->advance(n);
2752     }
2753
2754     PySwigIterator* operator - (ptrdiff_t n) const
2755     {
2756       return copy()->advance(-n);
2757     }
2758
2759     ptrdiff_t operator - (const PySwigIterator& x) const
2760     {
2761       return x.distance(*this);
2762     }
2763
2764     static swig_type_info* descriptor() {
2765       static int init = 0;
2766       static swig_type_info* desc = 0;
2767       if (!init) {
2768         desc = SWIG_TypeQuery("swig::PySwigIterator *");
2769         init = 1;
2770       }
2771       return desc;
2772     }
2773   };
2774 }
2775
2776
2777 SWIGINTERN int
2778 SWIG_AsVal_double (PyObject *obj, double *val)
2779 {
2780   int res = SWIG_TypeError;
2781   if (PyFloat_Check(obj)) {
2782     if (val) *val = PyFloat_AsDouble(obj);
2783     return SWIG_OK;
2784   } else if (PyInt_Check(obj)) {
2785     if (val) *val = PyInt_AsLong(obj);
2786     return SWIG_OK;
2787   } else if (PyLong_Check(obj)) {
2788     double v = PyLong_AsDouble(obj);
2789     if (!PyErr_Occurred()) {
2790       if (val) *val = v;
2791       return SWIG_OK;
2792     } else {
2793       PyErr_Clear();
2794     }
2795   }
2796 #ifdef SWIG_PYTHON_CAST_MODE
2797   {
2798     int dispatch = 0;
2799     double d = PyFloat_AsDouble(obj);
2800     if (!PyErr_Occurred()) {
2801       if (val) *val = d;
2802       return SWIG_AddCast(SWIG_OK);
2803     } else {
2804       PyErr_Clear();
2805     }
2806     if (!dispatch) {
2807       long v = PyLong_AsLong(obj);
2808       if (!PyErr_Occurred()) {
2809         if (val) *val = v;
2810         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2811       } else {
2812         PyErr_Clear();
2813       }
2814     }
2815   }
2816 #endif
2817   return res;
2818 }
2819
2820
2821 #include <float.h>
2822
2823
2824 #include <math.h>
2825
2826
2827 SWIGINTERNINLINE int
2828 SWIG_CanCastAsInteger(double *d, double min, double max) {
2829   double x = *d;
2830   if ((min <= x && x <= max)) {
2831    double fx = floor(x);
2832    double cx = ceil(x);
2833    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2834    if ((errno == EDOM) || (errno == ERANGE)) {
2835      errno = 0;
2836    } else {
2837      double summ, reps, diff;
2838      if (rd < x) {
2839        diff = x - rd;
2840      } else if (rd > x) {
2841        diff = rd - x;
2842      } else {
2843        return 1;
2844      }
2845      summ = rd + x;
2846      reps = diff/summ;
2847      if (reps < 8*DBL_EPSILON) {
2848        *d = rd;
2849        return 1;
2850      }
2851    }
2852   }
2853   return 0;
2854 }
2855
2856
2857 SWIGINTERN int
2858 SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
2859 {
2860   if (PyInt_Check(obj)) {
2861     long v = PyInt_AsLong(obj);
2862     if (v >= 0) {
2863       if (val) *val = v;
2864       return SWIG_OK;
2865     } else {
2866       return SWIG_OverflowError;
2867     }
2868   } else if (PyLong_Check(obj)) {
2869     unsigned long v = PyLong_AsUnsignedLong(obj);
2870     if (!PyErr_Occurred()) {
2871       if (val) *val = v;
2872       return SWIG_OK;
2873     } else {
2874       PyErr_Clear();
2875     }
2876   }
2877 #ifdef SWIG_PYTHON_CAST_MODE
2878   {
2879     int dispatch = 0;
2880     unsigned long v = PyLong_AsUnsignedLong(obj);
2881     if (!PyErr_Occurred()) {
2882       if (val) *val = v;
2883       return SWIG_AddCast(SWIG_OK);
2884     } else {
2885       PyErr_Clear();
2886     }
2887     if (!dispatch) {
2888       double d;
2889       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2890       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2891         if (val) *val = (unsigned long)(d);
2892         return res;
2893       }
2894     }
2895   }
2896 #endif
2897   return SWIG_TypeError;
2898 }
2899
2900
2901 SWIGINTERNINLINE int
2902 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
2903 {
2904   unsigned long v;
2905   int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2906   if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
2907   return res;
2908 }
2909
2910
2911   #define SWIG_From_long   PyInt_FromLong
2912
2913
2914 SWIGINTERNINLINE PyObject *
2915 SWIG_From_ptrdiff_t  (ptrdiff_t value)
2916 {
2917   return SWIG_From_long  (static_cast< long >(value));
2918 }
2919
2920
2921 SWIGINTERNINLINE PyObject*
2922   SWIG_From_bool  (bool value)
2923 {
2924   return PyBool_FromLong(value ? 1 : 0);
2925 }
2926
2927
2928 SWIGINTERN int
2929 SWIG_AsVal_long (PyObject *obj, long* val)
2930 {
2931   if (PyInt_Check(obj)) {
2932     if (val) *val = PyInt_AsLong(obj);
2933     return SWIG_OK;
2934   } else if (PyLong_Check(obj)) {
2935     long v = PyLong_AsLong(obj);
2936     if (!PyErr_Occurred()) {
2937       if (val) *val = v;
2938       return SWIG_OK;
2939     } else {
2940       PyErr_Clear();
2941     }
2942   }
2943 #ifdef SWIG_PYTHON_CAST_MODE
2944   {
2945     int dispatch = 0;
2946     long v = PyInt_AsLong(obj);
2947     if (!PyErr_Occurred()) {
2948       if (val) *val = v;
2949       return SWIG_AddCast(SWIG_OK);
2950     } else {
2951       PyErr_Clear();
2952     }
2953     if (!dispatch) {
2954       double d;
2955       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2956       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2957         if (val) *val = (long)(d);
2958         return res;
2959       }
2960     }
2961   }
2962 #endif
2963   return SWIG_TypeError;
2964 }
2965
2966
2967 SWIGINTERNINLINE int
2968 SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
2969 {
2970   long v;
2971   int res = SWIG_AsVal_long (obj, val ? &v : 0);
2972   if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
2973   return res;
2974 }
2975
2976
2977 #include <stdexcept>
2978
2979
2980 #include <algorithm>
2981
2982
2983 #include <vector>
2984
2985
2986 #include <utility>
2987
2988
2989 #include <map>
2990 #include <algorithm>
2991 #include <stdexcept>
2992
2993
2994 #include <complex>
2995
2996
2997 namespace swig {
2998   template <class Type>
2999   struct noconst_traits {
3000     typedef Type noconst_type;
3001   };
3002
3003   template <class Type>
3004   struct noconst_traits<const Type> {
3005     typedef Type noconst_type;
3006   };
3007
3008   /*
3009     type categories
3010   */
3011   struct pointer_category { };
3012   struct value_category { };
3013
3014   /*
3015     General traits that provides type_name and type_info
3016   */
3017   template <class Type> struct traits { };
3018
3019   template <class Type>
3020   inline const char* type_name() {
3021     return traits<typename noconst_traits<Type >::noconst_type >::type_name();
3022   }
3023
3024   template <class Type>
3025   struct traits_info {
3026     static swig_type_info *type_query(std::string name) {
3027       name += " *";
3028       return SWIG_TypeQuery(name.c_str());
3029     }
3030     static swig_type_info *type_info() {
3031       static swig_type_info *info = type_query(type_name<Type>());
3032       return info;
3033     }
3034   };
3035
3036   template <class Type>
3037   inline swig_type_info *type_info() {
3038     return traits_info<Type>::type_info();
3039   }
3040
3041   /*
3042     Partial specialization for pointers
3043   */
3044   template <class Type> struct traits <Type *> {
3045     typedef pointer_category category;
3046     static std::string make_ptr_name(const char* name) {
3047       std::string ptrname = name;
3048       ptrname += " *";
3049       return ptrname;
3050     }
3051     static const char* type_name() {
3052       static std::string name = make_ptr_name(swig::type_name<Type>());
3053       return name.c_str();
3054     }
3055   };
3056
3057   template <class Type, class Category>
3058   struct traits_as { };
3059
3060   template <class Type, class Category>
3061   struct traits_check { };
3062
3063 }
3064
3065
3066 namespace swig {
3067   /*
3068     Traits that provides the from method
3069   */
3070   template <class Type> struct traits_from_ptr {
3071     static PyObject *from(Type *val, int owner = 0) {
3072       return SWIG_NewPointerObj(val, type_info<Type>(), owner);
3073     }
3074   };
3075
3076   template <class Type> struct traits_from {
3077     static PyObject *from(const Type& val) {
3078       return traits_from_ptr<Type>::from(new Type(val), 1);
3079     }
3080   };
3081
3082   template <class Type> struct traits_from<Type *> {
3083     static PyObject *from(Type* val) {
3084       return traits_from_ptr<Type>::from(val, 0);
3085     }
3086   };
3087
3088   template <class Type> struct traits_from<const Type *> {
3089     static PyObject *from(const Type* val) {
3090       return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
3091     }
3092   };
3093
3094
3095   template <class Type>
3096   inline PyObject *from(const Type& val) {
3097     return traits_from<Type>::from(val);
3098   }
3099
3100   template <class Type>
3101   inline PyObject *from_ptr(Type* val, int owner) {
3102     return traits_from_ptr<Type>::from(val, owner);
3103   }
3104
3105   /*
3106     Traits that provides the asval/as/check method
3107   */
3108   template <class Type>
3109   struct traits_asptr {
3110     static int asptr(PyObject *obj, Type **val) {
3111       Type *p;
3112       int res = (SWIG_ConvertPtr(obj, (void**)&p, type_info<Type>(), 0) == SWIG_OK) ? SWIG_OLDOBJ : 0;
3113       if (SWIG_IsOK(res)) {
3114         if (val) *val = p;
3115       }
3116       return res;
3117     }
3118   };
3119
3120   template <class Type>
3121   inline int asptr(PyObject *obj, Type **vptr) {
3122     return traits_asptr<Type>::asptr(obj, vptr);
3123   }
3124
3125   template <class Type>
3126   struct traits_asval {
3127     static int asval(PyObject *obj, Type *val) {
3128       if (val) {
3129         Type *p = 0;
3130         int res = traits_asptr<Type>::asptr(obj, &p);
3131         if (!SWIG_IsOK(res)) return res;
3132         if (p) {
3133           typedef typename noconst_traits<Type>::noconst_type noconst_type;
3134           *(const_cast<noconst_type*>(val)) = *p;
3135           if (SWIG_IsNewObj(res)){
3136             delete p;
3137             res = SWIG_DelNewMask(res);
3138           }
3139           return res;
3140         } else {
3141           return SWIG_ERROR;
3142         }
3143       } else {
3144         return traits_asptr<Type>::asptr(obj, (Type **)(0));
3145       }
3146     }
3147   };
3148
3149   template <class Type> struct traits_asval<Type*> {
3150     static int asval(PyObject *obj, Type **val) {
3151       if (val) {
3152         typedef typename noconst_traits<Type>::noconst_type noconst_type;
3153         noconst_type *p = 0;
3154         int res = traits_asptr<noconst_type>::asptr(obj,  &p);
3155         if (SWIG_IsOK(res)) {
3156           *(const_cast<noconst_type**>(val)) = p;
3157         }
3158         return res;
3159       } else {
3160         return traits_asptr<Type>::asptr(obj, (Type **)(0));
3161       }
3162     }
3163   };
3164
3165   template <class Type>
3166   inline int asval(PyObject *obj, Type *val) {
3167     return traits_asval<Type>::asval(obj, val);
3168   }
3169
3170   template <class Type>
3171   struct traits_as<Type, value_category> {
3172     static Type as(PyObject *obj, bool throw_error) {
3173       Type v;
3174       int res = asval(obj, &v);
3175       if (!obj || !SWIG_IsOK(res)) {
3176         if (!PyErr_Occurred()) {
3177           ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3178         }
3179         if (throw_error) throw std::invalid_argument("bad type");
3180       }
3181       return v;
3182     }
3183   };
3184
3185   template <class Type>
3186   struct traits_as<Type, pointer_category> {
3187     static Type as(PyObject *obj, bool throw_error) {
3188       Type *v = 0;
3189       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3190       if (SWIG_IsOK(res) && v) {
3191         if (SWIG_IsNewObj(res)) {
3192           Type r(*v);
3193           delete v;
3194           return r;
3195         } else {
3196           return *v;
3197         }
3198       } else {
3199         // Uninitialized return value, no Type() constructor required.
3200         static Type *v_def = (Type*) malloc(sizeof(Type));
3201         if (!PyErr_Occurred()) {
3202           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3203         }
3204         if (throw_error) throw std::invalid_argument("bad type");
3205         memset(v_def,0,sizeof(Type));
3206         return *v_def;
3207       }
3208     }
3209   };
3210
3211   template <class Type>
3212   struct traits_as<Type*, pointer_category> {
3213     static Type* as(PyObject *obj, bool throw_error) {
3214       Type *v = 0;
3215       int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
3216       if (SWIG_IsOK(res)) {
3217         return v;
3218       } else {
3219         if (!PyErr_Occurred()) {
3220           SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
3221         }
3222         if (throw_error) throw std::invalid_argument("bad type");
3223         return 0;
3224       }
3225     }
3226   };
3227
3228   template <class Type>
3229   inline Type as(PyObject *obj, bool te = false) {
3230     return traits_as<Type, typename traits<Type>::category>::as(obj, te);
3231   }
3232
3233   template <class Type>
3234   struct traits_check<Type, value_category> {
3235     static bool check(PyObject *obj) {
3236       int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
3237       return SWIG_IsOK(res) ? true : false;
3238     }
3239   };
3240
3241   template <class Type>
3242   struct traits_check<Type, pointer_category> {
3243     static bool check(PyObject *obj) {
3244       int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
3245       return SWIG_IsOK(res) ? true : false;
3246     }
3247   };
3248
3249   template <class Type>
3250   inline bool check(PyObject *obj) {
3251     return traits_check<Type, typename traits<Type>::category>::check(obj);
3252   }
3253 }
3254
3255
3256 #include <functional>
3257
3258 namespace std {
3259   template <>
3260   struct less <PyObject *>: public binary_function<PyObject *, PyObject *, bool>
3261   {
3262     bool
3263     operator()(PyObject * v, PyObject *w) const
3264     {
3265       bool res;
3266       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
3267       res = PyObject_Compare(v, w) < 0;
3268       SWIG_PYTHON_THREAD_END_BLOCK;
3269       return res;
3270     }
3271   };
3272
3273   template <>
3274   struct less <swig::PyObject_ptr>: public binary_function<swig::PyObject_ptr, swig::PyObject_ptr, bool>
3275   {
3276     bool
3277     operator()(const swig::PyObject_ptr& v, const swig::PyObject_ptr& w) const
3278     {
3279       return std::less<PyObject *>()(v, w);
3280     }
3281   };
3282
3283   template <>
3284   struct less <swig::PyObject_var>: public binary_function<swig::PyObject_var, swig::PyObject_var, bool>
3285   {
3286     bool
3287     operator()(const swig::PyObject_var& v, const swig::PyObject_var& w) const
3288     {
3289       return std::less<PyObject *>()(v, w);
3290     }
3291   };
3292
3293 }
3294
3295 namespace swig {
3296   template <> struct traits<PyObject *> {
3297     typedef value_category category;
3298     static const char* type_name() { return "PyObject *"; }
3299   };
3300
3301   template <>  struct traits_asval<PyObject * > {
3302     typedef PyObject * value_type;
3303     static int asval(PyObject *obj, value_type *val) {
3304       if (val) *val = obj;
3305       return SWIG_OK;
3306     }
3307   };
3308
3309   template <>
3310   struct traits_check<PyObject *, value_category> {
3311     static bool check(PyObject *) {
3312       return true;
3313     }
3314   };
3315
3316   template <>  struct traits_from<PyObject *> {
3317     typedef PyObject * value_type;
3318     static PyObject *from(const value_type& val) {
3319       Py_XINCREF(val);
3320       return val;
3321     }
3322   };
3323
3324 }
3325
3326 namespace swig {
3327   inline size_t
3328   check_index(ptrdiff_t i, size_t size, bool insert = false) {
3329     if ( i < 0 ) {
3330       if ((size_t) (-i) <= size)
3331         return (size_t) (i + size);
3332     } else if ( (size_t) i < size ) {
3333       return (size_t) i;
3334     } else if (insert && ((size_t) i == size)) {
3335       return size;
3336     }
3337
3338     throw std::out_of_range("index out of range");
3339   }
3340
3341   inline size_t
3342   slice_index(ptrdiff_t i, size_t size) {
3343     if ( i < 0 ) {
3344       if ((size_t) (-i) <= size) {
3345         return (size_t) (i + size);
3346       } else {
3347         throw std::out_of_range("index out of range");
3348       }
3349     } else {
3350       return ( (size_t) i < size ) ? ((size_t) i) : size;
3351     }
3352   }
3353
3354   template <class Sequence, class Difference>
3355   inline typename Sequence::iterator
3356   getpos(Sequence* self, Difference i)  {
3357     typename Sequence::iterator pos = self->begin();
3358     std::advance(pos, check_index(i,self->size()));
3359     return pos;
3360   }
3361
3362   template <class Sequence, class Difference>
3363   inline typename Sequence::const_iterator
3364   cgetpos(const Sequence* self, Difference i)  {
3365     typename Sequence::const_iterator pos = self->begin();
3366     std::advance(pos, check_index(i,self->size()));
3367     return pos;
3368   }
3369
3370   template <class Sequence, class Difference>
3371   inline Sequence*
3372   getslice(const Sequence* self, Difference i, Difference j) {
3373     typename Sequence::size_type size = self->size();
3374     typename Sequence::size_type ii = swig::check_index(i, size);
3375     typename Sequence::size_type jj = swig::slice_index(j, size);
3376
3377     if (jj > ii) {
3378       typename Sequence::const_iterator vb = self->begin();
3379       typename Sequence::const_iterator ve = self->begin();
3380       std::advance(vb,ii);
3381       std::advance(ve,jj);
3382       return new Sequence(vb, ve);
3383     } else {
3384       return new Sequence();
3385     }
3386   }
3387
3388   template <class Sequence, class Difference, class InputSeq>
3389   inline void
3390   setslice(Sequence* self, Difference i, Difference j, const InputSeq& v) {
3391     typename Sequence::size_type size = self->size();
3392     typename Sequence::size_type ii = swig::check_index(i, size, true);
3393     typename Sequence::size_type jj = swig::slice_index(j, size);
3394     if (jj < ii) jj = ii;
3395     size_t ssize = jj - ii;
3396     if (ssize <= v.size()) {
3397       typename Sequence::iterator sb = self->begin();
3398       typename InputSeq::const_iterator vmid = v.begin();
3399       std::advance(sb,ii);
3400       std::advance(vmid, jj - ii);
3401       self->insert(std::copy(v.begin(), vmid, sb), vmid, v.end());
3402     } else {
3403       typename Sequence::iterator sb = self->begin();
3404       typename Sequence::iterator se = self->begin();
3405       std::advance(sb,ii);
3406       std::advance(se,jj);
3407       self->erase(sb,se);
3408       self->insert(sb, v.begin(), v.end());
3409     }
3410   }
3411
3412   template <class Sequence, class Difference>
3413   inline void
3414   delslice(Sequence* self, Difference i, Difference j) {
3415     typename Sequence::size_type size = self->size();
3416     typename Sequence::size_type ii = swig::check_index(i, size, true);
3417     typename Sequence::size_type jj = swig::slice_index(j, size);
3418     if (jj > ii) {
3419       typename Sequence::iterator sb = self->begin();
3420       typename Sequence::iterator se = self->begin();
3421       std::advance(sb,ii);
3422       std::advance(se,jj);
3423       self->erase(sb,se);
3424     }
3425   }
3426 }
3427
3428
3429 #if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
3430 #  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
3431 #    define SWIG_STD_NOITERATOR_TRAITS_STL
3432 #  endif
3433 #endif
3434
3435 #if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
3436 #include <iterator>
3437 #else
3438 namespace std {
3439   template <class Iterator>
3440   struct iterator_traits {
3441     typedef ptrdiff_t difference_type;
3442     typedef typename Iterator::value_type value_type;
3443   };
3444
3445   template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
3446   struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
3447     typedef Distance difference_type;
3448     typedef T value_type;
3449   };
3450
3451   template <class T>
3452   struct iterator_traits<T*> {
3453     typedef T value_type;
3454     typedef ptrdiff_t difference_type;
3455   };
3456
3457   template<typename _InputIterator>
3458   inline typename iterator_traits<_InputIterator>::difference_type
3459   distance(_InputIterator __first, _InputIterator __last)
3460   {
3461     typename iterator_traits<_InputIterator>::difference_type __n = 0;
3462     while (__first != __last) {
3463       ++__first; ++__n;
3464     }
3465     return __n;
3466   }
3467 }
3468 #endif
3469
3470
3471 namespace swig {
3472   template<typename OutIterator>
3473   class PySwigIterator_T :  public PySwigIterator
3474   {
3475   public:
3476     typedef OutIterator out_iterator;
3477     typedef typename std::iterator_traits<out_iterator>::value_type value_type;
3478     typedef PySwigIterator_T<out_iterator> self_type;
3479
3480     PySwigIterator_T(out_iterator curr, PyObject *seq)
3481       : PySwigIterator(seq), current(curr)
3482     {
3483     }
3484
3485     const out_iterator& get_current() const
3486     {
3487       return current;
3488     }
3489
3490
3491     bool equal (const PySwigIterator &iter) const
3492     {
3493       const self_type *iters = dynamic_cast<const self_type *>(&iter);
3494       if (iters) {
3495         return (current == iters->get_current());
3496       } else {
3497         throw std::invalid_argument("bad iterator type");
3498       }
3499     }
3500
3501     ptrdiff_t distance(const PySwigIterator &iter) const
3502     {
3503       const self_type *iters = dynamic_cast<const self_type *>(&iter);
3504       if (iters) {
3505         return std::distance(current, iters->get_current());
3506       } else {
3507         throw std::invalid_argument("bad iterator type");
3508       }
3509     }
3510
3511   protected:
3512     out_iterator current;
3513   };
3514
3515   template <class ValueType>
3516   struct from_oper
3517   {
3518     typedef const ValueType& argument_type;
3519     typedef PyObject *result_type;
3520     result_type operator()(argument_type v) const
3521     {
3522       return swig::from(v);
3523     }
3524   };
3525
3526   template<typename OutIterator,
3527            typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3528            typename FromOper = from_oper<ValueType> >
3529   class PySwigIteratorOpen_T :  public PySwigIterator_T<OutIterator>
3530   {
3531   public:
3532     FromOper from;
3533     typedef OutIterator out_iterator;
3534     typedef ValueType value_type;
3535     typedef PySwigIterator_T<out_iterator>  base;
3536     typedef PySwigIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
3537
3538     PySwigIteratorOpen_T(out_iterator curr, PyObject *seq)
3539       : PySwigIterator_T<OutIterator>(curr, seq)
3540     {
3541     }
3542
3543     PyObject *value() const {
3544       return from(static_cast<const value_type&>(*(base::current)));
3545     }
3546
3547     PySwigIterator *copy() const
3548     {
3549       return new self_type(*this);
3550     }
3551
3552     PySwigIterator *incr(size_t n = 1)
3553     {
3554       while (n--) {
3555         ++base::current;
3556       }
3557       return this;
3558     }
3559
3560     PySwigIterator *decr(size_t n = 1)
3561     {
3562       while (n--) {
3563         --base::current;
3564       }
3565       return this;
3566     }
3567   };
3568
3569   template<typename OutIterator,
3570            typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
3571            typename FromOper = from_oper<ValueType> >
3572   class PySwigIteratorClosed_T :  public PySwigIterator_T<OutIterator>
3573   {
3574   public:
3575     FromOper from;
3576     typedef OutIterator out_iterator;
3577     typedef ValueType value_type;
3578     typedef PySwigIterator_T<out_iterator>  base;
3579     typedef PySwigIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
3580
3581     PySwigIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
3582       : PySwigIterator_T<OutIterator>(curr, seq), begin(first), end(last)
3583     {
3584     }
3585
3586     PyObject *value() const {
3587       if (base::current == end) {
3588         throw stop_iteration();
3589       } else {
3590         return from(static_cast<const value_type&>(*(base::current)));
3591       }
3592     }
3593
3594     PySwigIterator *copy() const
3595     {
3596       return new self_type(*this);
3597     }
3598
3599     PySwigIterator *incr(size_t n = 1)
3600     {
3601       while (n--) {
3602         if (base::current == end) {
3603           throw stop_iteration();
3604         } else {
3605           ++base::current;
3606         }
3607       }
3608       return this;
3609     }
3610
3611     PySwigIterator *decr(size_t n = 1)
3612     {
3613       while (n--) {
3614         if (base::current == begin) {
3615           throw stop_iteration();
3616         } else {
3617           --base::current;
3618         }
3619       }
3620       return this;
3621     }
3622
3623   private:
3624     out_iterator begin;
3625     out_iterator end;
3626   };
3627
3628   template<typename OutIter>
3629   inline PySwigIterator*
3630   make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
3631   {
3632     return new PySwigIteratorClosed_T<OutIter>(current, begin, end, seq);
3633   }
3634
3635   template<typename OutIter>
3636   inline PySwigIterator*
3637   make_output_iterator(const OutIter& current, PyObject *seq = 0)
3638   {
3639     return new PySwigIteratorOpen_T<OutIter>(current, seq);
3640   }
3641 }
3642
3643
3644 namespace swig
3645 {
3646   template <class T>
3647   struct PySequence_Ref
3648   {
3649     PySequence_Ref(PyObject* seq, int index)
3650       : _seq(seq), _index(index)
3651     {
3652     }
3653
3654     operator T () const
3655     {
3656       swig::PyObject_var item = PySequence_GetItem(_seq, _index);
3657       try {
3658         return swig::as<T>(item, true);
3659       } catch (std::exception& e) {
3660         char msg[1024];
3661         sprintf(msg, "in sequence element %d ", _index);
3662         if (!PyErr_Occurred()) {
3663           ::SWIG_Error(SWIG_TypeError,  swig::type_name<T>());
3664         }
3665         SWIG_Python_AddErrorMsg(msg);
3666         SWIG_Python_AddErrorMsg(e.what());
3667         throw;
3668       }
3669     }
3670
3671     PySequence_Ref& operator=(const T& v)
3672     {
3673       PySequence_SetItem(_seq, _index, swig::from<T>(v));
3674       return *this;
3675     }
3676
3677   private:
3678     PyObject* _seq;
3679     int _index;
3680   };
3681
3682   template <class T>
3683   struct PySequence_ArrowProxy
3684   {
3685     PySequence_ArrowProxy(const T& x): m_value(x) {}
3686     const T* operator->() const { return &m_value; }
3687     operator const T*() const { return &m_value; }
3688     T m_value;
3689   };
3690
3691   template <class T, class Reference >
3692   struct PySequence_InputIterator
3693   {
3694     typedef PySequence_InputIterator<T, Reference > self;
3695
3696     typedef std::random_access_iterator_tag iterator_category;
3697     typedef Reference reference;
3698     typedef T value_type;
3699     typedef T* pointer;
3700     typedef int difference_type;
3701
3702     PySequence_InputIterator()
3703     {
3704     }
3705
3706     PySequence_InputIterator(PyObject* seq, int index)
3707       : _seq(seq), _index(index)
3708     {
3709     }
3710
3711     reference operator*() const
3712     {
3713       return reference(_seq, _index);
3714     }
3715
3716     PySequence_ArrowProxy<T>
3717     operator->() const {
3718       return PySequence_ArrowProxy<T>(operator*());
3719     }
3720
3721     bool operator==(const self& ri) const
3722     {
3723       return (_index == ri._index) && (_seq == ri._seq);
3724     }
3725
3726     bool operator!=(const self& ri) const
3727     {
3728       return !(operator==(ri));
3729     }
3730
3731     self& operator ++ ()
3732     {
3733       ++_index;
3734       return *this;
3735     }
3736
3737     self& operator -- ()
3738     {
3739       --_index;
3740       return *this;
3741     }
3742
3743     self& operator += (difference_type n)
3744     {
3745       _index += n;
3746       return *this;
3747     }
3748
3749     self operator +(difference_type n) const
3750     {
3751       return self(_seq, _index + n);
3752     }
3753
3754     self& operator -= (difference_type n)
3755     {
3756       _index -= n;
3757       return *this;
3758     }
3759
3760     self operator -(difference_type n) const
3761     {
3762       return self(_seq, _index - n);
3763     }
3764
3765     difference_type operator - (const self& ri) const
3766     {
3767       return _index - ri._index;
3768     }
3769
3770     bool operator < (const self& ri) const
3771     {
3772       return _index < ri._index;
3773     }
3774
3775     reference
3776     operator[](difference_type n) const
3777     {
3778       return reference(_seq, _index + n);
3779     }
3780
3781   private:
3782     PyObject* _seq;
3783     difference_type _index;
3784   };
3785
3786   template <class T>
3787   struct PySequence_Cont
3788   {
3789     typedef PySequence_Ref<T> reference;
3790     typedef const PySequence_Ref<T> const_reference;
3791     typedef T value_type;
3792     typedef T* pointer;
3793     typedef int difference_type;
3794     typedef int size_type;
3795     typedef const pointer const_pointer;
3796     typedef PySequence_InputIterator<T, reference> iterator;
3797     typedef PySequence_InputIterator<T, const_reference> const_iterator;
3798
3799     PySequence_Cont(PyObject* seq) : _seq(0)
3800     {
3801       if (!PySequence_Check(seq)) {
3802         throw std::invalid_argument("a sequence is expected");
3803       }
3804       _seq = seq;
3805       Py_INCREF(_seq);
3806     }
3807
3808     ~PySequence_Cont()
3809     {
3810       Py_XDECREF(_seq);
3811     }
3812
3813     size_type size() const
3814     {
3815       return static_cast<size_type>(PySequence_Size(_seq));
3816     }
3817
3818     bool empty() const
3819     {
3820       return size() == 0;
3821     }
3822
3823     iterator begin()
3824     {
3825       return iterator(_seq, 0);
3826     }
3827
3828     const_iterator begin() const
3829     {
3830       return const_iterator(_seq, 0);
3831     }
3832
3833     iterator end()
3834     {
3835       return iterator(_seq, size());
3836     }
3837
3838     const_iterator end() const
3839     {
3840       return const_iterator(_seq, size());
3841     }
3842
3843     reference operator[](difference_type n)
3844     {
3845       return reference(_seq, n);
3846     }
3847
3848     const_reference operator[](difference_type n)  const
3849     {
3850       return const_reference(_seq, n);
3851     }
3852
3853     bool check(bool set_err = true) const
3854     {
3855       int s = size();
3856       for (int i = 0; i < s; ++i) {
3857         swig::PyObject_var item = PySequence_GetItem(_seq, i);
3858         if (!swig::check<value_type>(item)) {
3859           if (set_err) {
3860             char msg[1024];
3861             sprintf(msg, "in sequence element %d", i);
3862             SWIG_Error(SWIG_RuntimeError, msg);
3863           }
3864           return false;
3865         }
3866       }
3867       return true;
3868     }
3869
3870   private:
3871     PyObject* _seq;
3872   };
3873
3874 }
3875
3876
3877 SWIGINTERNINLINE PyObject *
3878 SWIG_From_int  (int value)
3879 {
3880   return SWIG_From_long  (value);
3881 }
3882
3883
3884 #include "howto_square_ff.h"
3885 #include "howto_square2_ff.h"
3886
3887
3888 SWIGINTERNINLINE PyObject*
3889 SWIG_From_unsigned_SS_long  (unsigned long value)
3890 {
3891   return (value > LONG_MAX) ?
3892     PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3893 }
3894
3895
3896 SWIGINTERNINLINE PyObject *
3897 SWIG_From_unsigned_SS_int  (unsigned int value)
3898 {
3899   return SWIG_From_unsigned_SS_long  (value);
3900 }
3901
3902
3903   #define SWIG_From_double   PyFloat_FromDouble
3904
3905
3906 SWIGINTERN swig_type_info*
3907 SWIG_pchar_descriptor(void)
3908 {
3909   static int init = 0;
3910   static swig_type_info* info = 0;
3911   if (!init) {
3912     info = SWIG_TypeQuery("_p_char");
3913     init = 1;
3914   }
3915   return info;
3916 }
3917
3918
3919 SWIGINTERNINLINE PyObject *
3920 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3921 {
3922   if (carray) {
3923     if (size > INT_MAX) {
3924       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3925       return pchar_descriptor ?
3926         SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3927     } else {
3928       return PyString_FromStringAndSize(carray, static_cast< int >(size));
3929     }
3930   } else {
3931     return SWIG_Py_Void();
3932   }
3933 }
3934
3935
3936 SWIGINTERNINLINE PyObject *
3937 SWIG_From_std_string  (const std::string& s)
3938 {
3939   if (s.size()) {
3940     return SWIG_FromCharPtrAndSize(s.data(), s.size());
3941   } else {
3942     return SWIG_FromCharPtrAndSize(s.c_str(), 0);
3943   }
3944 }
3945
3946
3947 #include <limits.h>
3948 #if !defined(SWIG_NO_LLONG_MAX)
3949 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3950 #   define LLONG_MAX __LONG_LONG_MAX__
3951 #   define LLONG_MIN (-LLONG_MAX - 1LL)
3952 #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3953 # endif
3954 #endif
3955
3956
3957 SWIGINTERN int
3958 SWIG_AsVal_int (PyObject * obj, int *val)
3959 {
3960   long v;
3961   int res = SWIG_AsVal_long (obj, &v);
3962   if (SWIG_IsOK(res)) {
3963     if ((v < INT_MIN || v > INT_MAX)) {
3964       return SWIG_OverflowError;
3965     } else {
3966       if (val) *val = static_cast< int >(v);
3967     }
3968   }
3969   return res;
3970 }
3971
3972 #ifdef __cplusplus
3973 extern "C" {
3974 #endif
3975 SWIGINTERN PyObject *_wrap_delete_PySwigIterator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3976   PyObject *resultobj = 0;
3977   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
3978   void *argp1 = 0 ;
3979   int res1 = 0 ;
3980   PyObject * obj0 = 0 ;
3981
3982   if(!PyArg_UnpackTuple(args,(char *)"delete_PySwigIterator",1,1,&obj0)) SWIG_fail;
3983   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
3984   if (!SWIG_IsOK(res1)) {
3985     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PySwigIterator" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
3986   }
3987   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
3988   delete arg1;
3989   resultobj = SWIG_Py_Void();
3990   return resultobj;
3991 fail:
3992   return NULL;
3993 }
3994
3995
3996 SWIGINTERN PyObject *_wrap_PySwigIterator_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3997   PyObject *resultobj = 0;
3998   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
3999   void *argp1 = 0 ;
4000   int res1 = 0 ;
4001   PyObject * obj0 = 0 ;
4002   PyObject *result = 0 ;
4003
4004   if(!PyArg_UnpackTuple(args,(char *)"PySwigIterator_value",1,1,&obj0)) SWIG_fail;
4005   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4006   if (!SWIG_IsOK(res1)) {
4007     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_value" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4008   }
4009   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4010   try {
4011     result = (PyObject *)((swig::PySwigIterator const *)arg1)->value();
4012   }
4013   catch(swig::stop_iteration &_e) {
4014     {
4015       (void)_e;
4016       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4017       SWIG_fail;
4018     }
4019   }
4020
4021   resultobj = result;
4022   return resultobj;
4023 fail:
4024   return NULL;
4025 }
4026
4027
4028 SWIGINTERN PyObject *_wrap_PySwigIterator_incr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4029   PyObject *resultobj = 0;
4030   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4031   size_t arg2 = (size_t) 1 ;
4032   void *argp1 = 0 ;
4033   int res1 = 0 ;
4034   size_t val2 ;
4035   int ecode2 = 0 ;
4036   PyObject * obj0 = 0 ;
4037   PyObject * obj1 = 0 ;
4038   char *  kwnames[] = {
4039     (char *) "self",(char *) "n", NULL
4040   };
4041   swig::PySwigIterator *result = 0 ;
4042
4043   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PySwigIterator_incr",kwnames,&obj0,&obj1)) SWIG_fail;
4044   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4045   if (!SWIG_IsOK(res1)) {
4046     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_incr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4047   }
4048   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4049   if (obj1) {
4050     ecode2 = SWIG_AsVal_size_t(obj1, &val2);
4051     if (!SWIG_IsOK(ecode2)) {
4052       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_incr" "', argument " "2"" of type '" "size_t""'");
4053     }
4054     arg2 = static_cast< size_t >(val2);
4055   }
4056   try {
4057     result = (swig::PySwigIterator *)(arg1)->incr(arg2);
4058   }
4059   catch(swig::stop_iteration &_e) {
4060     {
4061       (void)_e;
4062       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4063       SWIG_fail;
4064     }
4065   }
4066
4067   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4068   return resultobj;
4069 fail:
4070   return NULL;
4071 }
4072
4073
4074 SWIGINTERN PyObject *_wrap_PySwigIterator_decr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4075   PyObject *resultobj = 0;
4076   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4077   size_t arg2 = (size_t) 1 ;
4078   void *argp1 = 0 ;
4079   int res1 = 0 ;
4080   size_t val2 ;
4081   int ecode2 = 0 ;
4082   PyObject * obj0 = 0 ;
4083   PyObject * obj1 = 0 ;
4084   char *  kwnames[] = {
4085     (char *) "self",(char *) "n", NULL
4086   };
4087   swig::PySwigIterator *result = 0 ;
4088
4089   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PySwigIterator_decr",kwnames,&obj0,&obj1)) SWIG_fail;
4090   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4091   if (!SWIG_IsOK(res1)) {
4092     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_decr" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4093   }
4094   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4095   if (obj1) {
4096     ecode2 = SWIG_AsVal_size_t(obj1, &val2);
4097     if (!SWIG_IsOK(ecode2)) {
4098       SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_decr" "', argument " "2"" of type '" "size_t""'");
4099     }
4100     arg2 = static_cast< size_t >(val2);
4101   }
4102   try {
4103     result = (swig::PySwigIterator *)(arg1)->decr(arg2);
4104   }
4105   catch(swig::stop_iteration &_e) {
4106     {
4107       (void)_e;
4108       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4109       SWIG_fail;
4110     }
4111   }
4112
4113   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4114   return resultobj;
4115 fail:
4116   return NULL;
4117 }
4118
4119
4120 SWIGINTERN PyObject *_wrap_PySwigIterator_distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4121   PyObject *resultobj = 0;
4122   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4123   swig::PySwigIterator *arg2 = 0 ;
4124   void *argp1 = 0 ;
4125   int res1 = 0 ;
4126   void *argp2 = 0 ;
4127   int res2 = 0 ;
4128   PyObject * obj0 = 0 ;
4129   PyObject * obj1 = 0 ;
4130   char *  kwnames[] = {
4131     (char *) "self",(char *) "x", NULL
4132   };
4133   ptrdiff_t result;
4134
4135   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PySwigIterator_distance",kwnames,&obj0,&obj1)) SWIG_fail;
4136   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4137   if (!SWIG_IsOK(res1)) {
4138     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_distance" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4139   }
4140   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4141   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
4142   if (!SWIG_IsOK(res2)) {
4143     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4144   }
4145   if (!argp2) {
4146     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_distance" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4147   }
4148   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
4149   try {
4150     result = ((swig::PySwigIterator const *)arg1)->distance((swig::PySwigIterator const &)*arg2);
4151   }
4152   catch(std::invalid_argument &_e) {
4153     SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
4154   }
4155
4156   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
4157   return resultobj;
4158 fail:
4159   return NULL;
4160 }
4161
4162
4163 SWIGINTERN PyObject *_wrap_PySwigIterator_equal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4164   PyObject *resultobj = 0;
4165   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4166   swig::PySwigIterator *arg2 = 0 ;
4167   void *argp1 = 0 ;
4168   int res1 = 0 ;
4169   void *argp2 = 0 ;
4170   int res2 = 0 ;
4171   PyObject * obj0 = 0 ;
4172   PyObject * obj1 = 0 ;
4173   char *  kwnames[] = {
4174     (char *) "self",(char *) "x", NULL
4175   };
4176   bool result;
4177
4178   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PySwigIterator_equal",kwnames,&obj0,&obj1)) SWIG_fail;
4179   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4180   if (!SWIG_IsOK(res1)) {
4181     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_equal" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4182   }
4183   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4184   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
4185   if (!SWIG_IsOK(res2)) {
4186     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4187   }
4188   if (!argp2) {
4189     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator_equal" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4190   }
4191   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
4192   try {
4193     result = (bool)((swig::PySwigIterator const *)arg1)->equal((swig::PySwigIterator const &)*arg2);
4194   }
4195   catch(std::invalid_argument &_e) {
4196     SWIG_Python_Raise(SWIG_NewPointerObj((new std::invalid_argument(static_cast< const std::invalid_argument& >(_e))),SWIGTYPE_p_std__invalid_argument,SWIG_POINTER_OWN), "std::invalid_argument", SWIGTYPE_p_std__invalid_argument); SWIG_fail;
4197   }
4198
4199   resultobj = SWIG_From_bool(static_cast< bool >(result));
4200   return resultobj;
4201 fail:
4202   return NULL;
4203 }
4204
4205
4206 SWIGINTERN PyObject *_wrap_PySwigIterator_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4207   PyObject *resultobj = 0;
4208   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4209   void *argp1 = 0 ;
4210   int res1 = 0 ;
4211   PyObject * obj0 = 0 ;
4212   swig::PySwigIterator *result = 0 ;
4213
4214   if(!PyArg_UnpackTuple(args,(char *)"PySwigIterator_copy",1,1,&obj0)) SWIG_fail;
4215   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4216   if (!SWIG_IsOK(res1)) {
4217     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_copy" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4218   }
4219   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4220   result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->copy();
4221   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
4222   return resultobj;
4223 fail:
4224   return NULL;
4225 }
4226
4227
4228 SWIGINTERN PyObject *_wrap_PySwigIterator_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4229   PyObject *resultobj = 0;
4230   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4231   void *argp1 = 0 ;
4232   int res1 = 0 ;
4233   PyObject * obj0 = 0 ;
4234   PyObject *result = 0 ;
4235
4236   if(!PyArg_UnpackTuple(args,(char *)"PySwigIterator_next",1,1,&obj0)) SWIG_fail;
4237   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4238   if (!SWIG_IsOK(res1)) {
4239     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_next" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4240   }
4241   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4242   try {
4243     result = (PyObject *)(arg1)->next();
4244   }
4245   catch(swig::stop_iteration &_e) {
4246     {
4247       (void)_e;
4248       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4249       SWIG_fail;
4250     }
4251   }
4252
4253   resultobj = result;
4254   return resultobj;
4255 fail:
4256   return NULL;
4257 }
4258
4259
4260 SWIGINTERN PyObject *_wrap_PySwigIterator_previous(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4261   PyObject *resultobj = 0;
4262   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4263   void *argp1 = 0 ;
4264   int res1 = 0 ;
4265   PyObject * obj0 = 0 ;
4266   PyObject *result = 0 ;
4267
4268   if(!PyArg_UnpackTuple(args,(char *)"PySwigIterator_previous",1,1,&obj0)) SWIG_fail;
4269   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4270   if (!SWIG_IsOK(res1)) {
4271     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_previous" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4272   }
4273   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4274   try {
4275     result = (PyObject *)(arg1)->previous();
4276   }
4277   catch(swig::stop_iteration &_e) {
4278     {
4279       (void)_e;
4280       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4281       SWIG_fail;
4282     }
4283   }
4284
4285   resultobj = result;
4286   return resultobj;
4287 fail:
4288   return NULL;
4289 }
4290
4291
4292 SWIGINTERN PyObject *_wrap_PySwigIterator_advance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4293   PyObject *resultobj = 0;
4294   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4295   ptrdiff_t arg2 ;
4296   void *argp1 = 0 ;
4297   int res1 = 0 ;
4298   ptrdiff_t val2 ;
4299   int ecode2 = 0 ;
4300   PyObject * obj0 = 0 ;
4301   PyObject * obj1 = 0 ;
4302   char *  kwnames[] = {
4303     (char *) "self",(char *) "n", NULL
4304   };
4305   swig::PySwigIterator *result = 0 ;
4306
4307   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PySwigIterator_advance",kwnames,&obj0,&obj1)) SWIG_fail;
4308   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4309   if (!SWIG_IsOK(res1)) {
4310     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator_advance" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4311   }
4312   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4313   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
4314   if (!SWIG_IsOK(ecode2)) {
4315     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
4316   }
4317   arg2 = static_cast< ptrdiff_t >(val2);
4318   try {
4319     result = (swig::PySwigIterator *)(arg1)->advance(arg2);
4320   }
4321   catch(swig::stop_iteration &_e) {
4322     {
4323       (void)_e;
4324       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4325       SWIG_fail;
4326     }
4327   }
4328
4329   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4330   return resultobj;
4331 fail:
4332   return NULL;
4333 }
4334
4335
4336 SWIGINTERN PyObject *_wrap_PySwigIterator___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4337   PyObject *resultobj = 0;
4338   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4339   swig::PySwigIterator *arg2 = 0 ;
4340   void *argp1 = 0 ;
4341   int res1 = 0 ;
4342   void *argp2 = 0 ;
4343   int res2 = 0 ;
4344   PyObject * obj0 = 0 ;
4345   PyObject * obj1 = 0 ;
4346   char *  kwnames[] = {
4347     (char *) "self",(char *) "x", NULL
4348   };
4349   bool result;
4350
4351   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PySwigIterator___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4352   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4353   if (!SWIG_IsOK(res1)) {
4354     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___eq__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4355   }
4356   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4357   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
4358   if (!SWIG_IsOK(res2)) {
4359     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4360   }
4361   if (!argp2) {
4362     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___eq__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4363   }
4364   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
4365   result = (bool)((swig::PySwigIterator const *)arg1)->operator ==((swig::PySwigIterator const &)*arg2);
4366   resultobj = SWIG_From_bool(static_cast< bool >(result));
4367   return resultobj;
4368 fail:
4369   return NULL;
4370 }
4371
4372
4373 SWIGINTERN PyObject *_wrap_PySwigIterator___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4374   PyObject *resultobj = 0;
4375   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4376   swig::PySwigIterator *arg2 = 0 ;
4377   void *argp1 = 0 ;
4378   int res1 = 0 ;
4379   void *argp2 = 0 ;
4380   int res2 = 0 ;
4381   PyObject * obj0 = 0 ;
4382   PyObject * obj1 = 0 ;
4383   char *  kwnames[] = {
4384     (char *) "self",(char *) "x", NULL
4385   };
4386   bool result;
4387
4388   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PySwigIterator___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4389   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4390   if (!SWIG_IsOK(res1)) {
4391     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___ne__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4392   }
4393   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4394   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
4395   if (!SWIG_IsOK(res2)) {
4396     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4397   }
4398   if (!argp2) {
4399     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___ne__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4400   }
4401   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
4402   result = (bool)((swig::PySwigIterator const *)arg1)->operator !=((swig::PySwigIterator const &)*arg2);
4403   resultobj = SWIG_From_bool(static_cast< bool >(result));
4404   return resultobj;
4405 fail:
4406   return NULL;
4407 }
4408
4409
4410 SWIGINTERN PyObject *_wrap_PySwigIterator___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4411   PyObject *resultobj = 0;
4412   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4413   ptrdiff_t arg2 ;
4414   void *argp1 = 0 ;
4415   int res1 = 0 ;
4416   ptrdiff_t val2 ;
4417   int ecode2 = 0 ;
4418   PyObject * obj0 = 0 ;
4419   PyObject * obj1 = 0 ;
4420   char *  kwnames[] = {
4421     (char *) "self",(char *) "n", NULL
4422   };
4423   swig::PySwigIterator *result = 0 ;
4424
4425   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PySwigIterator___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
4426   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
4427   if (!SWIG_IsOK(res1)) {
4428     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___iadd__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4429   }
4430   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4431   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
4432   if (!SWIG_IsOK(ecode2)) {
4433     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
4434   }
4435   arg2 = static_cast< ptrdiff_t >(val2);
4436   try {
4437     {
4438       swig::PySwigIterator &_result_ref = (arg1)->operator +=(arg2);
4439       result = (swig::PySwigIterator *) &_result_ref;
4440     }
4441   }
4442   catch(swig::stop_iteration &_e) {
4443     {
4444       (void)_e;
4445       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4446       SWIG_fail;
4447     }
4448   }
4449
4450   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
4451   return resultobj;
4452 fail:
4453   return NULL;
4454 }
4455
4456
4457 SWIGINTERN PyObject *_wrap_PySwigIterator___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4458   PyObject *resultobj = 0;
4459   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4460   ptrdiff_t arg2 ;
4461   void *argp1 = 0 ;
4462   int res1 = 0 ;
4463   ptrdiff_t val2 ;
4464   int ecode2 = 0 ;
4465   PyObject * obj0 = 0 ;
4466   PyObject * obj1 = 0 ;
4467   char *  kwnames[] = {
4468     (char *) "self",(char *) "n", NULL
4469   };
4470   swig::PySwigIterator *result = 0 ;
4471
4472   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PySwigIterator___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
4473   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_DISOWN |  0 );
4474   if (!SWIG_IsOK(res1)) {
4475     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___isub__" "', argument " "1"" of type '" "swig::PySwigIterator *""'");
4476   }
4477   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4478   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
4479   if (!SWIG_IsOK(ecode2)) {
4480     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
4481   }
4482   arg2 = static_cast< ptrdiff_t >(val2);
4483   try {
4484     {
4485       swig::PySwigIterator &_result_ref = (arg1)->operator -=(arg2);
4486       result = (swig::PySwigIterator *) &_result_ref;
4487     }
4488   }
4489   catch(swig::stop_iteration &_e) {
4490     {
4491       (void)_e;
4492       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4493       SWIG_fail;
4494     }
4495   }
4496
4497   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
4498   return resultobj;
4499 fail:
4500   return NULL;
4501 }
4502
4503
4504 SWIGINTERN PyObject *_wrap_PySwigIterator___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4505   PyObject *resultobj = 0;
4506   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4507   ptrdiff_t arg2 ;
4508   void *argp1 = 0 ;
4509   int res1 = 0 ;
4510   ptrdiff_t val2 ;
4511   int ecode2 = 0 ;
4512   PyObject * obj0 = 0 ;
4513   PyObject * obj1 = 0 ;
4514   char *  kwnames[] = {
4515     (char *) "self",(char *) "n", NULL
4516   };
4517   swig::PySwigIterator *result = 0 ;
4518
4519   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PySwigIterator___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4520   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4521   if (!SWIG_IsOK(res1)) {
4522     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___add__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4523   }
4524   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4525   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
4526   if (!SWIG_IsOK(ecode2)) {
4527     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
4528   }
4529   arg2 = static_cast< ptrdiff_t >(val2);
4530   try {
4531     result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator +(arg2);
4532   }
4533   catch(swig::stop_iteration &_e) {
4534     {
4535       (void)_e;
4536       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4537       SWIG_fail;
4538     }
4539   }
4540
4541   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
4542   return resultobj;
4543 fail:
4544   return NULL;
4545 }
4546
4547
4548 SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4549   PyObject *resultobj = 0;
4550   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4551   ptrdiff_t arg2 ;
4552   void *argp1 = 0 ;
4553   int res1 = 0 ;
4554   ptrdiff_t val2 ;
4555   int ecode2 = 0 ;
4556   PyObject * obj0 = 0 ;
4557   PyObject * obj1 = 0 ;
4558   swig::PySwigIterator *result = 0 ;
4559
4560   if(!PyArg_UnpackTuple(args,(char *)"PySwigIterator___sub__",2,2,&obj0,&obj1)) SWIG_fail;
4561   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4562   if (!SWIG_IsOK(res1)) {
4563     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4564   }
4565   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4566   ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
4567   if (!SWIG_IsOK(ecode2)) {
4568     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
4569   }
4570   arg2 = static_cast< ptrdiff_t >(val2);
4571   try {
4572     result = (swig::PySwigIterator *)((swig::PySwigIterator const *)arg1)->operator -(arg2);
4573   }
4574   catch(swig::stop_iteration &_e) {
4575     {
4576       (void)_e;
4577       SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
4578       SWIG_fail;
4579     }
4580   }
4581
4582   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__PySwigIterator, SWIG_POINTER_OWN |  0 );
4583   return resultobj;
4584 fail:
4585   return NULL;
4586 }
4587
4588
4589 SWIGINTERN PyObject *_wrap_PySwigIterator___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4590   PyObject *resultobj = 0;
4591   swig::PySwigIterator *arg1 = (swig::PySwigIterator *) 0 ;
4592   swig::PySwigIterator *arg2 = 0 ;
4593   void *argp1 = 0 ;
4594   int res1 = 0 ;
4595   void *argp2 = 0 ;
4596   int res2 = 0 ;
4597   PyObject * obj0 = 0 ;
4598   PyObject * obj1 = 0 ;
4599   ptrdiff_t result;
4600
4601   if(!PyArg_UnpackTuple(args,(char *)"PySwigIterator___sub__",2,2,&obj0,&obj1)) SWIG_fail;
4602   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__PySwigIterator, 0 |  0 );
4603   if (!SWIG_IsOK(res1)) {
4604     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySwigIterator___sub__" "', argument " "1"" of type '" "swig::PySwigIterator const *""'");
4605   }
4606   arg1 = reinterpret_cast< swig::PySwigIterator * >(argp1);
4607   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__PySwigIterator,  0  | 0);
4608   if (!SWIG_IsOK(res2)) {
4609     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4610   }
4611   if (!argp2) {
4612     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PySwigIterator___sub__" "', argument " "2"" of type '" "swig::PySwigIterator const &""'");
4613   }
4614   arg2 = reinterpret_cast< swig::PySwigIterator * >(argp2);
4615   result = ((swig::PySwigIterator const *)arg1)->operator -((swig::PySwigIterator const &)*arg2);
4616   resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
4617   return resultobj;
4618 fail:
4619   return NULL;
4620 }
4621
4622
4623 SWIGINTERN PyObject *_wrap_PySwigIterator___sub__(PyObject *self, PyObject *args) {
4624   int argc;
4625   PyObject *argv[3];
4626   int ii;
4627
4628   if (!PyTuple_Check(args)) SWIG_fail;
4629   argc = (int)PyObject_Length(args);
4630   for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4631     argv[ii] = PyTuple_GET_ITEM(args,ii);
4632   }
4633   if (argc == 2) {
4634     int _v;
4635     void *vptr = 0;
4636     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4637     _v = SWIG_CheckState(res);
4638     if (_v) {
4639       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__PySwigIterator, 0);
4640       _v = SWIG_CheckState(res);
4641       if (_v) {
4642         return _wrap_PySwigIterator___sub____SWIG_1(self, args);
4643       }
4644     }
4645   }
4646   if (argc == 2) {
4647     int _v;
4648     void *vptr = 0;
4649     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__PySwigIterator, 0);
4650     _v = SWIG_CheckState(res);
4651     if (_v) {
4652       {
4653         int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
4654         _v = SWIG_CheckState(res);
4655       }
4656       if (_v) {
4657         return _wrap_PySwigIterator___sub____SWIG_0(self, args);
4658       }
4659     }
4660   }
4661
4662 fail:
4663   Py_INCREF(Py_NotImplemented);
4664   return Py_NotImplemented;
4665 }
4666
4667
4668 SWIGINTERN PyObject *PySwigIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4669   PyObject *obj;
4670   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4671   SWIG_TypeNewClientData(SWIGTYPE_p_swig__PySwigIterator, SWIG_NewClientData(obj));
4672   return SWIG_Py_Void();
4673 }
4674
4675 SWIGINTERN PyObject *_wrap_new_howto_square_ff_sptr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4676   PyObject *resultobj = 0;
4677   boost::shared_ptr< howto_square_ff > *result = 0 ;
4678
4679   if(!PyArg_UnpackTuple(args,(char *)"new_howto_square_ff_sptr",0,0)) SWIG_fail;
4680   result = (boost::shared_ptr< howto_square_ff > *)new boost::shared_ptr< howto_square_ff >();
4681   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, SWIG_POINTER_NEW |  0 );
4682   return resultobj;
4683 fail:
4684   return NULL;
4685 }
4686
4687
4688 SWIGINTERN PyObject *_wrap_new_howto_square_ff_sptr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4689   PyObject *resultobj = 0;
4690   howto_square_ff *arg1 = (howto_square_ff *) 0 ;
4691   void *argp1 = 0 ;
4692   int res1 = 0 ;
4693   PyObject * obj0 = 0 ;
4694   boost::shared_ptr< howto_square_ff > *result = 0 ;
4695
4696   if(!PyArg_UnpackTuple(args,(char *)"new_howto_square_ff_sptr",1,1,&obj0)) SWIG_fail;
4697   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_howto_square_ff, 0 |  0 );
4698   if (!SWIG_IsOK(res1)) {
4699     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_howto_square_ff_sptr" "', argument " "1"" of type '" "howto_square_ff *""'");
4700   }
4701   arg1 = reinterpret_cast< howto_square_ff * >(argp1);
4702   result = (boost::shared_ptr< howto_square_ff > *)new boost::shared_ptr< howto_square_ff >(arg1);
4703   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, SWIG_POINTER_NEW |  0 );
4704   return resultobj;
4705 fail:
4706   return NULL;
4707 }
4708
4709
4710 SWIGINTERN PyObject *_wrap_new_howto_square_ff_sptr(PyObject *self, PyObject *args) {
4711   int argc;
4712   PyObject *argv[2];
4713   int ii;
4714
4715   if (!PyTuple_Check(args)) SWIG_fail;
4716   argc = (int)PyObject_Length(args);
4717   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
4718     argv[ii] = PyTuple_GET_ITEM(args,ii);
4719   }
4720   if (argc == 0) {
4721     return _wrap_new_howto_square_ff_sptr__SWIG_0(self, args);
4722   }
4723   if (argc == 1) {
4724     int _v;
4725     void *vptr = 0;
4726     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_howto_square_ff, 0);
4727     _v = SWIG_CheckState(res);
4728     if (_v) {
4729       return _wrap_new_howto_square_ff_sptr__SWIG_1(self, args);
4730     }
4731   }
4732
4733 fail:
4734   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_howto_square_ff_sptr'.\n"
4735     "  Possible C/C++ prototypes are:\n"
4736     "    boost::shared_ptr< howto_square_ff >()\n"
4737     "    boost::shared_ptr< howto_square_ff >(howto_square_ff *)\n");
4738   return NULL;
4739 }
4740
4741
4742 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4743   PyObject *resultobj = 0;
4744   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
4745   void *argp1 = 0 ;
4746   int res1 = 0 ;
4747   PyObject * obj0 = 0 ;
4748   howto_square_ff *result = 0 ;
4749
4750   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr___deref__",1,1,&obj0)) SWIG_fail;
4751   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
4752   if (!SWIG_IsOK(res1)) {
4753     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > *""'");
4754   }
4755   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
4756   result = (howto_square_ff *)(arg1)->operator ->();
4757   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_howto_square_ff, 0 |  0 );
4758   return resultobj;
4759 fail:
4760   return NULL;
4761 }
4762
4763
4764 SWIGINTERN PyObject *_wrap_delete_howto_square_ff_sptr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4765   PyObject *resultobj = 0;
4766   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
4767   void *argp1 = 0 ;
4768   int res1 = 0 ;
4769   PyObject * obj0 = 0 ;
4770
4771   if(!PyArg_UnpackTuple(args,(char *)"delete_howto_square_ff_sptr",1,1,&obj0)) SWIG_fail;
4772   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, SWIG_POINTER_DISOWN |  0 );
4773   if (!SWIG_IsOK(res1)) {
4774     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_howto_square_ff_sptr" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > *""'");
4775   }
4776   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
4777   delete arg1;
4778   resultobj = SWIG_Py_Void();
4779   return resultobj;
4780 fail:
4781   return NULL;
4782 }
4783
4784
4785 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4786   PyObject *resultobj = 0;
4787   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
4788   void *argp1 = 0 ;
4789   int res1 = 0 ;
4790   PyObject * obj0 = 0 ;
4791   unsigned int result;
4792
4793   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr_history",1,1,&obj0)) SWIG_fail;
4794   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
4795   if (!SWIG_IsOK(res1)) {
4796     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_history" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > const *""'");
4797   }
4798   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
4799   result = (unsigned int)(*arg1)->history();
4800   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
4801   return resultobj;
4802 fail:
4803   return NULL;
4804 }
4805
4806
4807 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_output_multiple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4808   PyObject *resultobj = 0;
4809   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
4810   void *argp1 = 0 ;
4811   int res1 = 0 ;
4812   PyObject * obj0 = 0 ;
4813   int result;
4814
4815   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr_output_multiple",1,1,&obj0)) SWIG_fail;
4816   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
4817   if (!SWIG_IsOK(res1)) {
4818     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_output_multiple" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > const *""'");
4819   }
4820   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
4821   result = (int)(*arg1)->output_multiple();
4822   resultobj = SWIG_From_int(static_cast< int >(result));
4823   return resultobj;
4824 fail:
4825   return NULL;
4826 }
4827
4828
4829 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_relative_rate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4830   PyObject *resultobj = 0;
4831   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
4832   void *argp1 = 0 ;
4833   int res1 = 0 ;
4834   PyObject * obj0 = 0 ;
4835   double result;
4836
4837   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr_relative_rate",1,1,&obj0)) SWIG_fail;
4838   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
4839   if (!SWIG_IsOK(res1)) {
4840     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_relative_rate" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > const *""'");
4841   }
4842   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
4843   result = (double)(*arg1)->relative_rate();
4844   resultobj = SWIG_From_double(static_cast< double >(result));
4845   return resultobj;
4846 fail:
4847   return NULL;
4848 }
4849
4850
4851 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4852   PyObject *resultobj = 0;
4853   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
4854   void *argp1 = 0 ;
4855   int res1 = 0 ;
4856   PyObject * obj0 = 0 ;
4857   bool result;
4858
4859   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr_start",1,1,&obj0)) SWIG_fail;
4860   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
4861   if (!SWIG_IsOK(res1)) {
4862     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_start" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > *""'");
4863   }
4864   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
4865   result = (bool)(*arg1)->start();
4866   resultobj = SWIG_From_bool(static_cast< bool >(result));
4867   return resultobj;
4868 fail:
4869   return NULL;
4870 }
4871
4872
4873 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4874   PyObject *resultobj = 0;
4875   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
4876   void *argp1 = 0 ;
4877   int res1 = 0 ;
4878   PyObject * obj0 = 0 ;
4879   bool result;
4880
4881   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr_stop",1,1,&obj0)) SWIG_fail;
4882   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
4883   if (!SWIG_IsOK(res1)) {
4884     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_stop" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > *""'");
4885   }
4886   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
4887   result = (bool)(*arg1)->stop();
4888   resultobj = SWIG_From_bool(static_cast< bool >(result));
4889   return resultobj;
4890 fail:
4891   return NULL;
4892 }
4893
4894
4895 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_detail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4896   PyObject *resultobj = 0;
4897   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
4898   void *argp1 = 0 ;
4899   int res1 = 0 ;
4900   PyObject * obj0 = 0 ;
4901   gr_block_detail_sptr result;
4902
4903   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr_detail",1,1,&obj0)) SWIG_fail;
4904   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
4905   if (!SWIG_IsOK(res1)) {
4906     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_detail" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > const *""'");
4907   }
4908   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
4909   result = (*arg1)->detail();
4910   resultobj = SWIG_NewPointerObj((new gr_block_detail_sptr(static_cast< const gr_block_detail_sptr& >(result))), SWIGTYPE_p_boost__shared_ptrT_gr_block_detail_t, SWIG_POINTER_OWN |  0 );
4911   return resultobj;
4912 fail:
4913   return NULL;
4914 }
4915
4916
4917 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_set_detail(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4918   PyObject *resultobj = 0;
4919   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
4920   gr_block_detail_sptr arg2 ;
4921   void *argp1 = 0 ;
4922   int res1 = 0 ;
4923   void *argp2 ;
4924   int res2 = 0 ;
4925   PyObject * obj0 = 0 ;
4926   PyObject * obj1 = 0 ;
4927   char *  kwnames[] = {
4928     (char *) "self",(char *) "detail", NULL
4929   };
4930
4931   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:howto_square_ff_sptr_set_detail",kwnames,&obj0,&obj1)) SWIG_fail;
4932   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
4933   if (!SWIG_IsOK(res1)) {
4934     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_set_detail" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > *""'");
4935   }
4936   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
4937   {
4938     res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_gr_block_detail_t,  0  | 0);
4939     if (!SWIG_IsOK(res2)) {
4940       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "howto_square_ff_sptr_set_detail" "', argument " "2"" of type '" "gr_block_detail_sptr""'");
4941     }
4942     if (!argp2) {
4943       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "howto_square_ff_sptr_set_detail" "', argument " "2"" of type '" "gr_block_detail_sptr""'");
4944     } else {
4945       gr_block_detail_sptr * temp = reinterpret_cast< gr_block_detail_sptr * >(argp2);
4946       arg2 = *temp;
4947       if (SWIG_IsNewObj(res2)) delete temp;
4948     }
4949   }
4950   (*arg1)->set_detail(arg2);
4951   resultobj = SWIG_Py_Void();
4952   return resultobj;
4953 fail:
4954   return NULL;
4955 }
4956
4957
4958 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4959   PyObject *resultobj = 0;
4960   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
4961   void *argp1 = 0 ;
4962   int res1 = 0 ;
4963   PyObject * obj0 = 0 ;
4964   std::string result;
4965
4966   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr_name",1,1,&obj0)) SWIG_fail;
4967   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
4968   if (!SWIG_IsOK(res1)) {
4969     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_name" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > const *""'");
4970   }
4971   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
4972   result = (*arg1)->name();
4973   resultobj = SWIG_From_std_string(static_cast< std::string >(result));
4974   return resultobj;
4975 fail:
4976   return NULL;
4977 }
4978
4979
4980 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_input_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4981   PyObject *resultobj = 0;
4982   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
4983   void *argp1 = 0 ;
4984   int res1 = 0 ;
4985   PyObject * obj0 = 0 ;
4986   gr_io_signature_sptr result;
4987
4988   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr_input_signature",1,1,&obj0)) SWIG_fail;
4989   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
4990   if (!SWIG_IsOK(res1)) {
4991     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_input_signature" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > const *""'");
4992   }
4993   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
4994   result = (*arg1)->input_signature();
4995   resultobj = SWIG_NewPointerObj((new gr_io_signature_sptr(static_cast< const gr_io_signature_sptr& >(result))), SWIGTYPE_p_boost__shared_ptrT_gr_io_signature_t, SWIG_POINTER_OWN |  0 );
4996   return resultobj;
4997 fail:
4998   return NULL;
4999 }
5000
5001
5002 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_output_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5003   PyObject *resultobj = 0;
5004   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
5005   void *argp1 = 0 ;
5006   int res1 = 0 ;
5007   PyObject * obj0 = 0 ;
5008   gr_io_signature_sptr result;
5009
5010   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr_output_signature",1,1,&obj0)) SWIG_fail;
5011   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
5012   if (!SWIG_IsOK(res1)) {
5013     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_output_signature" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > const *""'");
5014   }
5015   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
5016   result = (*arg1)->output_signature();
5017   resultobj = SWIG_NewPointerObj((new gr_io_signature_sptr(static_cast< const gr_io_signature_sptr& >(result))), SWIGTYPE_p_boost__shared_ptrT_gr_io_signature_t, SWIG_POINTER_OWN |  0 );
5018   return resultobj;
5019 fail:
5020   return NULL;
5021 }
5022
5023
5024 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_unique_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5025   PyObject *resultobj = 0;
5026   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
5027   void *argp1 = 0 ;
5028   int res1 = 0 ;
5029   PyObject * obj0 = 0 ;
5030   long result;
5031
5032   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr_unique_id",1,1,&obj0)) SWIG_fail;
5033   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
5034   if (!SWIG_IsOK(res1)) {
5035     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_unique_id" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > const *""'");
5036   }
5037   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
5038   result = (long)(*arg1)->unique_id();
5039   resultobj = SWIG_From_long(static_cast< long >(result));
5040   return resultobj;
5041 fail:
5042   return NULL;
5043 }
5044
5045
5046 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_basic_block(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5047   PyObject *resultobj = 0;
5048   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
5049   void *argp1 = 0 ;
5050   int res1 = 0 ;
5051   PyObject * obj0 = 0 ;
5052   gr_basic_block_sptr result;
5053
5054   if(!PyArg_UnpackTuple(args,(char *)"howto_square_ff_sptr_basic_block",1,1,&obj0)) SWIG_fail;
5055   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
5056   if (!SWIG_IsOK(res1)) {
5057     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_basic_block" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > *""'");
5058   }
5059   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
5060   result = (*arg1)->basic_block();
5061   resultobj = SWIG_NewPointerObj((new gr_basic_block_sptr(static_cast< const gr_basic_block_sptr& >(result))), SWIGTYPE_p_boost__shared_ptrT_gr_basic_block_t, SWIG_POINTER_OWN |  0 );
5062   return resultobj;
5063 fail:
5064   return NULL;
5065 }
5066
5067
5068 SWIGINTERN PyObject *_wrap_howto_square_ff_sptr_check_topology(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5069   PyObject *resultobj = 0;
5070   boost::shared_ptr< howto_square_ff > *arg1 = (boost::shared_ptr< howto_square_ff > *) 0 ;
5071   int arg2 ;
5072   int arg3 ;
5073   void *argp1 = 0 ;
5074   int res1 = 0 ;
5075   int val2 ;
5076   int ecode2 = 0 ;
5077   int val3 ;
5078   int ecode3 = 0 ;
5079   PyObject * obj0 = 0 ;
5080   PyObject * obj1 = 0 ;
5081   PyObject * obj2 = 0 ;
5082   char *  kwnames[] = {
5083     (char *) "self",(char *) "ninputs",(char *) "noutputs", NULL
5084   };
5085   bool result;
5086
5087   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:howto_square_ff_sptr_check_topology",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5088   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, 0 |  0 );
5089   if (!SWIG_IsOK(res1)) {
5090     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square_ff_sptr_check_topology" "', argument " "1"" of type '" "boost::shared_ptr< howto_square_ff > *""'");
5091   }
5092   arg1 = reinterpret_cast< boost::shared_ptr< howto_square_ff > * >(argp1);
5093   ecode2 = SWIG_AsVal_int(obj1, &val2);
5094   if (!SWIG_IsOK(ecode2)) {
5095     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "howto_square_ff_sptr_check_topology" "', argument " "2"" of type '" "int""'");
5096   }
5097   arg2 = static_cast< int >(val2);
5098   ecode3 = SWIG_AsVal_int(obj2, &val3);
5099   if (!SWIG_IsOK(ecode3)) {
5100     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "howto_square_ff_sptr_check_topology" "', argument " "3"" of type '" "int""'");
5101   }
5102   arg3 = static_cast< int >(val3);
5103   result = (bool)(*arg1)->check_topology(arg2,arg3);
5104   resultobj = SWIG_From_bool(static_cast< bool >(result));
5105   return resultobj;
5106 fail:
5107   return NULL;
5108 }
5109
5110
5111 SWIGINTERN PyObject *howto_square_ff_sptr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5112   PyObject *obj;
5113   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5114   SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, SWIG_NewClientData(obj));
5115   return SWIG_Py_Void();
5116 }
5117
5118 SWIGINTERN PyObject *_wrap_square_ff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5119   PyObject *resultobj = 0;
5120   howto_square_ff_sptr result;
5121
5122   if(!PyArg_UnpackTuple(args,(char *)"square_ff",0,0)) SWIG_fail;
5123   result = howto_make_square_ff();
5124   resultobj = SWIG_NewPointerObj((new howto_square_ff_sptr(static_cast< const howto_square_ff_sptr& >(result))), SWIGTYPE_p_boost__shared_ptrT_howto_square_ff_t, SWIG_POINTER_OWN |  0 );
5125   return resultobj;
5126 fail:
5127   return NULL;
5128 }
5129
5130
5131 SWIGINTERN PyObject *_wrap_new_howto_square2_ff_sptr__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5132   PyObject *resultobj = 0;
5133   boost::shared_ptr< howto_square2_ff > *result = 0 ;
5134
5135   if(!PyArg_UnpackTuple(args,(char *)"new_howto_square2_ff_sptr",0,0)) SWIG_fail;
5136   result = (boost::shared_ptr< howto_square2_ff > *)new boost::shared_ptr< howto_square2_ff >();
5137   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, SWIG_POINTER_NEW |  0 );
5138   return resultobj;
5139 fail:
5140   return NULL;
5141 }
5142
5143
5144 SWIGINTERN PyObject *_wrap_new_howto_square2_ff_sptr__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5145   PyObject *resultobj = 0;
5146   howto_square2_ff *arg1 = (howto_square2_ff *) 0 ;
5147   void *argp1 = 0 ;
5148   int res1 = 0 ;
5149   PyObject * obj0 = 0 ;
5150   boost::shared_ptr< howto_square2_ff > *result = 0 ;
5151
5152   if(!PyArg_UnpackTuple(args,(char *)"new_howto_square2_ff_sptr",1,1,&obj0)) SWIG_fail;
5153   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_howto_square2_ff, 0 |  0 );
5154   if (!SWIG_IsOK(res1)) {
5155     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_howto_square2_ff_sptr" "', argument " "1"" of type '" "howto_square2_ff *""'");
5156   }
5157   arg1 = reinterpret_cast< howto_square2_ff * >(argp1);
5158   result = (boost::shared_ptr< howto_square2_ff > *)new boost::shared_ptr< howto_square2_ff >(arg1);
5159   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, SWIG_POINTER_NEW |  0 );
5160   return resultobj;
5161 fail:
5162   return NULL;
5163 }
5164
5165
5166 SWIGINTERN PyObject *_wrap_new_howto_square2_ff_sptr(PyObject *self, PyObject *args) {
5167   int argc;
5168   PyObject *argv[2];
5169   int ii;
5170
5171   if (!PyTuple_Check(args)) SWIG_fail;
5172   argc = (int)PyObject_Length(args);
5173   for (ii = 0; (ii < argc) && (ii < 1); ii++) {
5174     argv[ii] = PyTuple_GET_ITEM(args,ii);
5175   }
5176   if (argc == 0) {
5177     return _wrap_new_howto_square2_ff_sptr__SWIG_0(self, args);
5178   }
5179   if (argc == 1) {
5180     int _v;
5181     void *vptr = 0;
5182     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_howto_square2_ff, 0);
5183     _v = SWIG_CheckState(res);
5184     if (_v) {
5185       return _wrap_new_howto_square2_ff_sptr__SWIG_1(self, args);
5186     }
5187   }
5188
5189 fail:
5190   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_howto_square2_ff_sptr'.\n"
5191     "  Possible C/C++ prototypes are:\n"
5192     "    boost::shared_ptr< howto_square2_ff >()\n"
5193     "    boost::shared_ptr< howto_square2_ff >(howto_square2_ff *)\n");
5194   return NULL;
5195 }
5196
5197
5198 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr___deref__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5199   PyObject *resultobj = 0;
5200   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5201   void *argp1 = 0 ;
5202   int res1 = 0 ;
5203   PyObject * obj0 = 0 ;
5204   howto_square2_ff *result = 0 ;
5205
5206   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr___deref__",1,1,&obj0)) SWIG_fail;
5207   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5208   if (!SWIG_IsOK(res1)) {
5209     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr___deref__" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > *""'");
5210   }
5211   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5212   result = (howto_square2_ff *)(arg1)->operator ->();
5213   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_howto_square2_ff, 0 |  0 );
5214   return resultobj;
5215 fail:
5216   return NULL;
5217 }
5218
5219
5220 SWIGINTERN PyObject *_wrap_delete_howto_square2_ff_sptr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5221   PyObject *resultobj = 0;
5222   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5223   void *argp1 = 0 ;
5224   int res1 = 0 ;
5225   PyObject * obj0 = 0 ;
5226
5227   if(!PyArg_UnpackTuple(args,(char *)"delete_howto_square2_ff_sptr",1,1,&obj0)) SWIG_fail;
5228   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, SWIG_POINTER_DISOWN |  0 );
5229   if (!SWIG_IsOK(res1)) {
5230     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_howto_square2_ff_sptr" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > *""'");
5231   }
5232   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5233   delete arg1;
5234   resultobj = SWIG_Py_Void();
5235   return resultobj;
5236 fail:
5237   return NULL;
5238 }
5239
5240
5241 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_history(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5242   PyObject *resultobj = 0;
5243   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5244   void *argp1 = 0 ;
5245   int res1 = 0 ;
5246   PyObject * obj0 = 0 ;
5247   unsigned int result;
5248
5249   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr_history",1,1,&obj0)) SWIG_fail;
5250   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5251   if (!SWIG_IsOK(res1)) {
5252     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_history" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > const *""'");
5253   }
5254   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5255   result = (unsigned int)(*arg1)->history();
5256   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
5257   return resultobj;
5258 fail:
5259   return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_output_multiple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5264   PyObject *resultobj = 0;
5265   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5266   void *argp1 = 0 ;
5267   int res1 = 0 ;
5268   PyObject * obj0 = 0 ;
5269   int result;
5270
5271   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr_output_multiple",1,1,&obj0)) SWIG_fail;
5272   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5273   if (!SWIG_IsOK(res1)) {
5274     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_output_multiple" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > const *""'");
5275   }
5276   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5277   result = (int)(*arg1)->output_multiple();
5278   resultobj = SWIG_From_int(static_cast< int >(result));
5279   return resultobj;
5280 fail:
5281   return NULL;
5282 }
5283
5284
5285 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_relative_rate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5286   PyObject *resultobj = 0;
5287   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5288   void *argp1 = 0 ;
5289   int res1 = 0 ;
5290   PyObject * obj0 = 0 ;
5291   double result;
5292
5293   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr_relative_rate",1,1,&obj0)) SWIG_fail;
5294   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5295   if (!SWIG_IsOK(res1)) {
5296     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_relative_rate" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > const *""'");
5297   }
5298   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5299   result = (double)(*arg1)->relative_rate();
5300   resultobj = SWIG_From_double(static_cast< double >(result));
5301   return resultobj;
5302 fail:
5303   return NULL;
5304 }
5305
5306
5307 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5308   PyObject *resultobj = 0;
5309   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5310   void *argp1 = 0 ;
5311   int res1 = 0 ;
5312   PyObject * obj0 = 0 ;
5313   bool result;
5314
5315   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr_start",1,1,&obj0)) SWIG_fail;
5316   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5317   if (!SWIG_IsOK(res1)) {
5318     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_start" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > *""'");
5319   }
5320   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5321   result = (bool)(*arg1)->start();
5322   resultobj = SWIG_From_bool(static_cast< bool >(result));
5323   return resultobj;
5324 fail:
5325   return NULL;
5326 }
5327
5328
5329 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_stop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5330   PyObject *resultobj = 0;
5331   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5332   void *argp1 = 0 ;
5333   int res1 = 0 ;
5334   PyObject * obj0 = 0 ;
5335   bool result;
5336
5337   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr_stop",1,1,&obj0)) SWIG_fail;
5338   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5339   if (!SWIG_IsOK(res1)) {
5340     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_stop" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > *""'");
5341   }
5342   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5343   result = (bool)(*arg1)->stop();
5344   resultobj = SWIG_From_bool(static_cast< bool >(result));
5345   return resultobj;
5346 fail:
5347   return NULL;
5348 }
5349
5350
5351 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_detail(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5352   PyObject *resultobj = 0;
5353   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5354   void *argp1 = 0 ;
5355   int res1 = 0 ;
5356   PyObject * obj0 = 0 ;
5357   gr_block_detail_sptr result;
5358
5359   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr_detail",1,1,&obj0)) SWIG_fail;
5360   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5361   if (!SWIG_IsOK(res1)) {
5362     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_detail" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > const *""'");
5363   }
5364   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5365   result = (*arg1)->detail();
5366   resultobj = SWIG_NewPointerObj((new gr_block_detail_sptr(static_cast< const gr_block_detail_sptr& >(result))), SWIGTYPE_p_boost__shared_ptrT_gr_block_detail_t, SWIG_POINTER_OWN |  0 );
5367   return resultobj;
5368 fail:
5369   return NULL;
5370 }
5371
5372
5373 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_set_detail(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5374   PyObject *resultobj = 0;
5375   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5376   gr_block_detail_sptr arg2 ;
5377   void *argp1 = 0 ;
5378   int res1 = 0 ;
5379   void *argp2 ;
5380   int res2 = 0 ;
5381   PyObject * obj0 = 0 ;
5382   PyObject * obj1 = 0 ;
5383   char *  kwnames[] = {
5384     (char *) "self",(char *) "detail", NULL
5385   };
5386
5387   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:howto_square2_ff_sptr_set_detail",kwnames,&obj0,&obj1)) SWIG_fail;
5388   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5389   if (!SWIG_IsOK(res1)) {
5390     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_set_detail" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > *""'");
5391   }
5392   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5393   {
5394     res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_boost__shared_ptrT_gr_block_detail_t,  0  | 0);
5395     if (!SWIG_IsOK(res2)) {
5396       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "howto_square2_ff_sptr_set_detail" "', argument " "2"" of type '" "gr_block_detail_sptr""'");
5397     }
5398     if (!argp2) {
5399       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "howto_square2_ff_sptr_set_detail" "', argument " "2"" of type '" "gr_block_detail_sptr""'");
5400     } else {
5401       gr_block_detail_sptr * temp = reinterpret_cast< gr_block_detail_sptr * >(argp2);
5402       arg2 = *temp;
5403       if (SWIG_IsNewObj(res2)) delete temp;
5404     }
5405   }
5406   (*arg1)->set_detail(arg2);
5407   resultobj = SWIG_Py_Void();
5408   return resultobj;
5409 fail:
5410   return NULL;
5411 }
5412
5413
5414 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5415   PyObject *resultobj = 0;
5416   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5417   void *argp1 = 0 ;
5418   int res1 = 0 ;
5419   PyObject * obj0 = 0 ;
5420   std::string result;
5421
5422   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr_name",1,1,&obj0)) SWIG_fail;
5423   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5424   if (!SWIG_IsOK(res1)) {
5425     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_name" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > const *""'");
5426   }
5427   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5428   result = (*arg1)->name();
5429   resultobj = SWIG_From_std_string(static_cast< std::string >(result));
5430   return resultobj;
5431 fail:
5432   return NULL;
5433 }
5434
5435
5436 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_input_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5437   PyObject *resultobj = 0;
5438   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5439   void *argp1 = 0 ;
5440   int res1 = 0 ;
5441   PyObject * obj0 = 0 ;
5442   gr_io_signature_sptr result;
5443
5444   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr_input_signature",1,1,&obj0)) SWIG_fail;
5445   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5446   if (!SWIG_IsOK(res1)) {
5447     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_input_signature" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > const *""'");
5448   }
5449   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5450   result = (*arg1)->input_signature();
5451   resultobj = SWIG_NewPointerObj((new gr_io_signature_sptr(static_cast< const gr_io_signature_sptr& >(result))), SWIGTYPE_p_boost__shared_ptrT_gr_io_signature_t, SWIG_POINTER_OWN |  0 );
5452   return resultobj;
5453 fail:
5454   return NULL;
5455 }
5456
5457
5458 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_output_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5459   PyObject *resultobj = 0;
5460   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5461   void *argp1 = 0 ;
5462   int res1 = 0 ;
5463   PyObject * obj0 = 0 ;
5464   gr_io_signature_sptr result;
5465
5466   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr_output_signature",1,1,&obj0)) SWIG_fail;
5467   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5468   if (!SWIG_IsOK(res1)) {
5469     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_output_signature" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > const *""'");
5470   }
5471   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5472   result = (*arg1)->output_signature();
5473   resultobj = SWIG_NewPointerObj((new gr_io_signature_sptr(static_cast< const gr_io_signature_sptr& >(result))), SWIGTYPE_p_boost__shared_ptrT_gr_io_signature_t, SWIG_POINTER_OWN |  0 );
5474   return resultobj;
5475 fail:
5476   return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_unique_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5481   PyObject *resultobj = 0;
5482   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5483   void *argp1 = 0 ;
5484   int res1 = 0 ;
5485   PyObject * obj0 = 0 ;
5486   long result;
5487
5488   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr_unique_id",1,1,&obj0)) SWIG_fail;
5489   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5490   if (!SWIG_IsOK(res1)) {
5491     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_unique_id" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > const *""'");
5492   }
5493   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5494   result = (long)(*arg1)->unique_id();
5495   resultobj = SWIG_From_long(static_cast< long >(result));
5496   return resultobj;
5497 fail:
5498   return NULL;
5499 }
5500
5501
5502 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_basic_block(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5503   PyObject *resultobj = 0;
5504   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5505   void *argp1 = 0 ;
5506   int res1 = 0 ;
5507   PyObject * obj0 = 0 ;
5508   gr_basic_block_sptr result;
5509
5510   if(!PyArg_UnpackTuple(args,(char *)"howto_square2_ff_sptr_basic_block",1,1,&obj0)) SWIG_fail;
5511   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5512   if (!SWIG_IsOK(res1)) {
5513     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_basic_block" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > *""'");
5514   }
5515   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5516   result = (*arg1)->basic_block();
5517   resultobj = SWIG_NewPointerObj((new gr_basic_block_sptr(static_cast< const gr_basic_block_sptr& >(result))), SWIGTYPE_p_boost__shared_ptrT_gr_basic_block_t, SWIG_POINTER_OWN |  0 );
5518   return resultobj;
5519 fail:
5520   return NULL;
5521 }
5522
5523
5524 SWIGINTERN PyObject *_wrap_howto_square2_ff_sptr_check_topology(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5525   PyObject *resultobj = 0;
5526   boost::shared_ptr< howto_square2_ff > *arg1 = (boost::shared_ptr< howto_square2_ff > *) 0 ;
5527   int arg2 ;
5528   int arg3 ;
5529   void *argp1 = 0 ;
5530   int res1 = 0 ;
5531   int val2 ;
5532   int ecode2 = 0 ;
5533   int val3 ;
5534   int ecode3 = 0 ;
5535   PyObject * obj0 = 0 ;
5536   PyObject * obj1 = 0 ;
5537   PyObject * obj2 = 0 ;
5538   char *  kwnames[] = {
5539     (char *) "self",(char *) "ninputs",(char *) "noutputs", NULL
5540   };
5541   bool result;
5542
5543   if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:howto_square2_ff_sptr_check_topology",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5544   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, 0 |  0 );
5545   if (!SWIG_IsOK(res1)) {
5546     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "howto_square2_ff_sptr_check_topology" "', argument " "1"" of type '" "boost::shared_ptr< howto_square2_ff > *""'");
5547   }
5548   arg1 = reinterpret_cast< boost::shared_ptr< howto_square2_ff > * >(argp1);
5549   ecode2 = SWIG_AsVal_int(obj1, &val2);
5550   if (!SWIG_IsOK(ecode2)) {
5551     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "howto_square2_ff_sptr_check_topology" "', argument " "2"" of type '" "int""'");
5552   }
5553   arg2 = static_cast< int >(val2);
5554   ecode3 = SWIG_AsVal_int(obj2, &val3);
5555   if (!SWIG_IsOK(ecode3)) {
5556     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "howto_square2_ff_sptr_check_topology" "', argument " "3"" of type '" "int""'");
5557   }
5558   arg3 = static_cast< int >(val3);
5559   result = (bool)(*arg1)->check_topology(arg2,arg3);
5560   resultobj = SWIG_From_bool(static_cast< bool >(result));
5561   return resultobj;
5562 fail:
5563   return NULL;
5564 }
5565
5566
5567 SWIGINTERN PyObject *howto_square2_ff_sptr_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5568   PyObject *obj;
5569   if (!PyArg_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5570   SWIG_TypeNewClientData(SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, SWIG_NewClientData(obj));
5571   return SWIG_Py_Void();
5572 }
5573
5574 SWIGINTERN PyObject *_wrap_square2_ff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5575   PyObject *resultobj = 0;
5576   howto_square2_ff_sptr result;
5577
5578   if(!PyArg_UnpackTuple(args,(char *)"square2_ff",0,0)) SWIG_fail;
5579   result = howto_make_square2_ff();
5580   resultobj = SWIG_NewPointerObj((new howto_square2_ff_sptr(static_cast< const howto_square2_ff_sptr& >(result))), SWIGTYPE_p_boost__shared_ptrT_howto_square2_ff_t, SWIG_POINTER_OWN |  0 );
5581   return resultobj;
5582 fail:
5583   return NULL;
5584 }
5585
5586
5587 static PyMethodDef SwigMethods[] = {
5588          { (char *)"delete_PySwigIterator", _wrap_delete_PySwigIterator, METH_VARARGS, (char *)"delete_PySwigIterator(PySwigIterator self)"},
5589          { (char *)"PySwigIterator_value", _wrap_PySwigIterator_value, METH_VARARGS, (char *)"PySwigIterator_value(PySwigIterator self) -> PyObject"},
5590          { (char *)"PySwigIterator_incr", (PyCFunction) _wrap_PySwigIterator_incr, METH_VARARGS | METH_KEYWORDS, (char *)"PySwigIterator_incr(PySwigIterator self, size_t n=1) -> PySwigIterator"},
5591          { (char *)"PySwigIterator_decr", (PyCFunction) _wrap_PySwigIterator_decr, METH_VARARGS | METH_KEYWORDS, (char *)"PySwigIterator_decr(PySwigIterator self, size_t n=1) -> PySwigIterator"},
5592          { (char *)"PySwigIterator_distance", (PyCFunction) _wrap_PySwigIterator_distance, METH_VARARGS | METH_KEYWORDS, (char *)"PySwigIterator_distance(PySwigIterator self, PySwigIterator x) -> ptrdiff_t"},
5593          { (char *)"PySwigIterator_equal", (PyCFunction) _wrap_PySwigIterator_equal, METH_VARARGS | METH_KEYWORDS, (char *)"PySwigIterator_equal(PySwigIterator self, PySwigIterator x) -> bool"},
5594          { (char *)"PySwigIterator_copy", _wrap_PySwigIterator_copy, METH_VARARGS, (char *)"PySwigIterator_copy(PySwigIterator self) -> PySwigIterator"},
5595          { (char *)"PySwigIterator_next", _wrap_PySwigIterator_next, METH_VARARGS, (char *)"PySwigIterator_next(PySwigIterator self) -> PyObject"},
5596          { (char *)"PySwigIterator_previous", _wrap_PySwigIterator_previous, METH_VARARGS, (char *)"PySwigIterator_previous(PySwigIterator self) -> PyObject"},
5597          { (char *)"PySwigIterator_advance", (PyCFunction) _wrap_PySwigIterator_advance, METH_VARARGS | METH_KEYWORDS, (char *)"PySwigIterator_advance(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
5598          { (char *)"PySwigIterator___eq__", (PyCFunction) _wrap_PySwigIterator___eq__, METH_VARARGS | METH_KEYWORDS, (char *)"PySwigIterator___eq__(PySwigIterator self, PySwigIterator x) -> bool"},
5599          { (char *)"PySwigIterator___ne__", (PyCFunction) _wrap_PySwigIterator___ne__, METH_VARARGS | METH_KEYWORDS, (char *)"PySwigIterator___ne__(PySwigIterator self, PySwigIterator x) -> bool"},
5600          { (char *)"PySwigIterator___iadd__", (PyCFunction) _wrap_PySwigIterator___iadd__, METH_VARARGS | METH_KEYWORDS, (char *)"PySwigIterator___iadd__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
5601          { (char *)"PySwigIterator___isub__", (PyCFunction) _wrap_PySwigIterator___isub__, METH_VARARGS | METH_KEYWORDS, (char *)"PySwigIterator___isub__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
5602          { (char *)"PySwigIterator___add__", (PyCFunction) _wrap_PySwigIterator___add__, METH_VARARGS | METH_KEYWORDS, (char *)"PySwigIterator___add__(PySwigIterator self, ptrdiff_t n) -> PySwigIterator"},
5603          { (char *)"PySwigIterator___sub__", _wrap_PySwigIterator___sub__, METH_VARARGS, (char *)"\n"
5604                 "__sub__(ptrdiff_t n) -> PySwigIterator\n"
5605                 "PySwigIterator___sub__(PySwigIterator self, PySwigIterator x) -> ptrdiff_t\n"
5606                 ""},
5607          { (char *)"PySwigIterator_swigregister", PySwigIterator_swigregister, METH_VARARGS, NULL},
5608          { (char *)"new_howto_square_ff_sptr", _wrap_new_howto_square_ff_sptr, METH_VARARGS, (char *)"\n"
5609                 "howto_square_ff_sptr()\n"
5610                 "new_howto_square_ff_sptr( p) -> howto_square_ff_sptr\n"
5611                 ""},
5612          { (char *)"howto_square_ff_sptr___deref__", _wrap_howto_square_ff_sptr___deref__, METH_VARARGS, (char *)"howto_square_ff_sptr___deref__(howto_square_ff_sptr self)"},
5613          { (char *)"delete_howto_square_ff_sptr", _wrap_delete_howto_square_ff_sptr, METH_VARARGS, (char *)"delete_howto_square_ff_sptr(howto_square_ff_sptr self)"},
5614          { (char *)"howto_square_ff_sptr_history", _wrap_howto_square_ff_sptr_history, METH_VARARGS, (char *)"howto_square_ff_sptr_history(howto_square_ff_sptr self) -> unsigned int"},
5615          { (char *)"howto_square_ff_sptr_output_multiple", _wrap_howto_square_ff_sptr_output_multiple, METH_VARARGS, (char *)"howto_square_ff_sptr_output_multiple(howto_square_ff_sptr self) -> int"},
5616          { (char *)"howto_square_ff_sptr_relative_rate", _wrap_howto_square_ff_sptr_relative_rate, METH_VARARGS, (char *)"howto_square_ff_sptr_relative_rate(howto_square_ff_sptr self) -> double"},
5617          { (char *)"howto_square_ff_sptr_start", _wrap_howto_square_ff_sptr_start, METH_VARARGS, (char *)"howto_square_ff_sptr_start(howto_square_ff_sptr self) -> bool"},
5618          { (char *)"howto_square_ff_sptr_stop", _wrap_howto_square_ff_sptr_stop, METH_VARARGS, (char *)"howto_square_ff_sptr_stop(howto_square_ff_sptr self) -> bool"},
5619          { (char *)"howto_square_ff_sptr_detail", _wrap_howto_square_ff_sptr_detail, METH_VARARGS, (char *)"howto_square_ff_sptr_detail(howto_square_ff_sptr self) -> gr_block_detail_sptr"},
5620          { (char *)"howto_square_ff_sptr_set_detail", (PyCFunction) _wrap_howto_square_ff_sptr_set_detail, METH_VARARGS | METH_KEYWORDS, (char *)"howto_square_ff_sptr_set_detail(howto_square_ff_sptr self, gr_block_detail_sptr detail)"},
5621          { (char *)"howto_square_ff_sptr_name", _wrap_howto_square_ff_sptr_name, METH_VARARGS, (char *)"howto_square_ff_sptr_name(howto_square_ff_sptr self) -> string"},
5622          { (char *)"howto_square_ff_sptr_input_signature", _wrap_howto_square_ff_sptr_input_signature, METH_VARARGS, (char *)"howto_square_ff_sptr_input_signature(howto_square_ff_sptr self) -> gr_io_signature_sptr"},
5623          { (char *)"howto_square_ff_sptr_output_signature", _wrap_howto_square_ff_sptr_output_signature, METH_VARARGS, (char *)"howto_square_ff_sptr_output_signature(howto_square_ff_sptr self) -> gr_io_signature_sptr"},
5624          { (char *)"howto_square_ff_sptr_unique_id", _wrap_howto_square_ff_sptr_unique_id, METH_VARARGS, (char *)"howto_square_ff_sptr_unique_id(howto_square_ff_sptr self) -> long"},
5625          { (char *)"howto_square_ff_sptr_basic_block", _wrap_howto_square_ff_sptr_basic_block, METH_VARARGS, (char *)"howto_square_ff_sptr_basic_block(howto_square_ff_sptr self) -> gr_basic_block_sptr"},
5626          { (char *)"howto_square_ff_sptr_check_topology", (PyCFunction) _wrap_howto_square_ff_sptr_check_topology, METH_VARARGS | METH_KEYWORDS, (char *)"howto_square_ff_sptr_check_topology(howto_square_ff_sptr self, int ninputs, int noutputs) -> bool"},
5627          { (char *)"howto_square_ff_sptr_swigregister", howto_square_ff_sptr_swigregister, METH_VARARGS, NULL},
5628          { (char *)"square_ff", _wrap_square_ff, METH_VARARGS, (char *)"square_ff() -> howto_square_ff_sptr"},
5629          { (char *)"new_howto_square2_ff_sptr", _wrap_new_howto_square2_ff_sptr, METH_VARARGS, (char *)"\n"
5630                 "howto_square2_ff_sptr()\n"
5631                 "new_howto_square2_ff_sptr( p) -> howto_square2_ff_sptr\n"
5632                 ""},
5633          { (char *)"howto_square2_ff_sptr___deref__", _wrap_howto_square2_ff_sptr___deref__, METH_VARARGS, (char *)"howto_square2_ff_sptr___deref__(howto_square2_ff_sptr self)"},
5634          { (char *)"delete_howto_square2_ff_sptr", _wrap_delete_howto_square2_ff_sptr, METH_VARARGS, (char *)"delete_howto_square2_ff_sptr(howto_square2_ff_sptr self)"},
5635          { (char *)"howto_square2_ff_sptr_history", _wrap_howto_square2_ff_sptr_history, METH_VARARGS, (char *)"howto_square2_ff_sptr_history(howto_square2_ff_sptr self) -> unsigned int"},
5636          { (char *)"howto_square2_ff_sptr_output_multiple", _wrap_howto_square2_ff_sptr_output_multiple, METH_VARARGS, (char *)"howto_square2_ff_sptr_output_multiple(howto_square2_ff_sptr self) -> int"},
5637          { (char *)"howto_square2_ff_sptr_relative_rate", _wrap_howto_square2_ff_sptr_relative_rate, METH_VARARGS, (char *)"howto_square2_ff_sptr_relative_rate(howto_square2_ff_sptr self) -> double"},
5638          { (char *)"howto_square2_ff_sptr_start", _wrap_howto_square2_ff_sptr_start, METH_VARARGS, (char *)"howto_square2_ff_sptr_start(howto_square2_ff_sptr self) -> bool"},
5639          { (char *)"howto_square2_ff_sptr_stop", _wrap_howto_square2_ff_sptr_stop, METH_VARARGS, (char *)"howto_square2_ff_sptr_stop(howto_square2_ff_sptr self) -> bool"},
5640          { (char *)"howto_square2_ff_sptr_detail", _wrap_howto_square2_ff_sptr_detail, METH_VARARGS, (char *)"howto_square2_ff_sptr_detail(howto_square2_ff_sptr self) -> gr_block_detail_sptr"},
5641          { (char *)"howto_square2_ff_sptr_set_detail", (PyCFunction) _wrap_howto_square2_ff_sptr_set_detail, METH_VARARGS | METH_KEYWORDS, (char *)"howto_square2_ff_sptr_set_detail(howto_square2_ff_sptr self, gr_block_detail_sptr detail)"},
5642          { (char *)"howto_square2_ff_sptr_name", _wrap_howto_square2_ff_sptr_name, METH_VARARGS, (char *)"howto_square2_ff_sptr_name(howto_square2_ff_sptr self) -> string"},
5643          { (char *)"howto_square2_ff_sptr_input_signature", _wrap_howto_square2_ff_sptr_input_signature, METH_VARARGS, (char *)"howto_square2_ff_sptr_input_signature(howto_square2_ff_sptr self) -> gr_io_signature_sptr"},
5644          { (char *)"howto_square2_ff_sptr_output_signature", _wrap_howto_square2_ff_sptr_output_signature, METH_VARARGS, (char *)"howto_square2_ff_sptr_output_signature(howto_square2_ff_sptr self) -> gr_io_signature_sptr"},
5645          { (char *)"howto_square2_ff_sptr_unique_id", _wrap_howto_square2_ff_sptr_unique_id, METH_VARARGS, (char *)"howto_square2_ff_sptr_unique_id(howto_square2_ff_sptr self) -> long"},
5646          { (char *)"howto_square2_ff_sptr_basic_block", _wrap_howto_square2_ff_sptr_basic_block, METH_VARARGS, (char *)"howto_square2_ff_sptr_basic_block(howto_square2_ff_sptr self) -> gr_basic_block_sptr"},
5647          { (char *)"howto_square2_ff_sptr_check_topology", (PyCFunction) _wrap_howto_square2_ff_sptr_check_topology, METH_VARARGS | METH_KEYWORDS, (char *)"howto_square2_ff_sptr_check_topology(howto_square2_ff_sptr self, int ninputs, int noutputs) -> bool"},
5648          { (char *)"howto_square2_ff_sptr_swigregister", howto_square2_ff_sptr_swigregister, METH_VARARGS, NULL},
5649          { (char *)"square2_ff", _wrap_square2_ff, METH_VARARGS, (char *)"square2_ff() -> howto_square2_ff_sptr"},
5650          { NULL, NULL, 0, NULL }
5651 };
5652
5653
5654 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
5655
5656 static void *_p_howto_square2_ffTo_p_gr_sync_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5657     return (void *)((gr_sync_block *)  ((howto_square2_ff *) x));
5658 }
5659 static void *_p_gr_sync_decimatorTo_p_gr_sync_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5660     return (void *)((gr_sync_block *)  ((gr_sync_decimator *) x));
5661 }
5662 static void *_p_gr_sync_interpolatorTo_p_gr_sync_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5663     return (void *)((gr_sync_block *)  ((gr_sync_interpolator *) x));
5664 }
5665 static void *_p_howto_square2_ffTo_p_gr_basic_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5666     return (void *)((gr_basic_block *) (gr_block *)(gr_sync_block *) ((howto_square2_ff *) x));
5667 }
5668 static void *_p_gr_sync_decimatorTo_p_gr_basic_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5669     return (void *)((gr_basic_block *) (gr_block *)(gr_sync_block *) ((gr_sync_decimator *) x));
5670 }
5671 static void *_p_gr_hier_block2To_p_gr_basic_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5672     return (void *)((gr_basic_block *)  ((gr_hier_block2 *) x));
5673 }
5674 static void *_p_gr_sync_blockTo_p_gr_basic_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5675     return (void *)((gr_basic_block *) (gr_block *) ((gr_sync_block *) x));
5676 }
5677 static void *_p_gr_blockTo_p_gr_basic_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5678     return (void *)((gr_basic_block *)  ((gr_block *) x));
5679 }
5680 static void *_p_gr_sync_interpolatorTo_p_gr_basic_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5681     return (void *)((gr_basic_block *) (gr_block *)(gr_sync_block *) ((gr_sync_interpolator *) x));
5682 }
5683 static void *_p_gr_top_blockTo_p_gr_basic_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5684     return (void *)((gr_basic_block *) (gr_hier_block2 *) ((gr_top_block *) x));
5685 }
5686 static void *_p_howto_square_ffTo_p_gr_basic_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5687     return (void *)((gr_basic_block *) (gr_block *) ((howto_square_ff *) x));
5688 }
5689 static void *_p_howto_square2_ffTo_p_gr_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5690     return (void *)((gr_block *) (gr_sync_block *) ((howto_square2_ff *) x));
5691 }
5692 static void *_p_gr_sync_decimatorTo_p_gr_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5693     return (void *)((gr_block *) (gr_sync_block *) ((gr_sync_decimator *) x));
5694 }
5695 static void *_p_gr_sync_blockTo_p_gr_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5696     return (void *)((gr_block *)  ((gr_sync_block *) x));
5697 }
5698 static void *_p_gr_sync_interpolatorTo_p_gr_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5699     return (void *)((gr_block *) (gr_sync_block *) ((gr_sync_interpolator *) x));
5700 }
5701 static void *_p_howto_square_ffTo_p_gr_block(void *x, int *SWIGUNUSEDPARM(newmemory)) {
5702     return (void *)((gr_block *)  ((howto_square_ff *) x));
5703 }
5704 static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
5705 static swig_type_info _swigt__p_boost__shared_ptrT_gr_basic_block_t = {"_p_boost__shared_ptrT_gr_basic_block_t", "boost::shared_ptr< gr_basic_block > *|gr_basic_block_sptr *", 0, 0, (void*)0, 0};
5706 static swig_type_info _swigt__p_boost__shared_ptrT_gr_block_detail_t = {"_p_boost__shared_ptrT_gr_block_detail_t", "boost::shared_ptr< gr_block_detail > *|gr_block_detail_sptr *", 0, 0, (void*)0, 0};
5707 static swig_type_info _swigt__p_boost__shared_ptrT_gr_block_t = {"_p_boost__shared_ptrT_gr_block_t", "boost::shared_ptr< gr_block > *|gr_block_sptr *", 0, 0, (void*)0, 0};
5708 static swig_type_info _swigt__p_boost__shared_ptrT_gr_buffer_reader_t = {"_p_boost__shared_ptrT_gr_buffer_reader_t", "boost::shared_ptr< gr_buffer_reader > *|gr_buffer_reader_sptr *", 0, 0, (void*)0, 0};
5709 static swig_type_info _swigt__p_boost__shared_ptrT_gr_buffer_t = {"_p_boost__shared_ptrT_gr_buffer_t", "boost::shared_ptr< gr_buffer > *|gr_buffer_sptr *", 0, 0, (void*)0, 0};
5710 static swig_type_info _swigt__p_boost__shared_ptrT_gr_dispatcher_t = {"_p_boost__shared_ptrT_gr_dispatcher_t", "boost::shared_ptr< gr_dispatcher > *|gr_dispatcher_sptr *", 0, 0, (void*)0, 0};
5711 static swig_type_info _swigt__p_boost__shared_ptrT_gr_hier_block2_t = {"_p_boost__shared_ptrT_gr_hier_block2_t", "boost::shared_ptr< gr_hier_block2 > *|gr_hier_block2_sptr *", 0, 0, (void*)0, 0};
5712 static swig_type_info _swigt__p_boost__shared_ptrT_gr_io_signature_t = {"_p_boost__shared_ptrT_gr_io_signature_t", "boost::shared_ptr< gr_io_signature > *|gr_io_signature_sptr *", 0, 0, (void*)0, 0};
5713 static swig_type_info _swigt__p_boost__shared_ptrT_gr_message_t = {"_p_boost__shared_ptrT_gr_message_t", "boost::shared_ptr< gr_message > *|gr_message_sptr *", 0, 0, (void*)0, 0};
5714 static swig_type_info _swigt__p_boost__shared_ptrT_gr_msg_queue_t = {"_p_boost__shared_ptrT_gr_msg_queue_t", "boost::shared_ptr< gr_msg_queue > *|gr_msg_queue_sptr *", 0, 0, (void*)0, 0};
5715 static swig_type_info _swigt__p_boost__shared_ptrT_gr_single_threaded_scheduler_t = {"_p_boost__shared_ptrT_gr_single_threaded_scheduler_t", "boost::shared_ptr< gr_single_threaded_scheduler > *|gr_single_threaded_scheduler_sptr *", 0, 0, (void*)0, 0};
5716 static swig_type_info _swigt__p_boost__shared_ptrT_gr_top_block_t = {"_p_boost__shared_ptrT_gr_top_block_t", "boost::shared_ptr< gr_top_block > *|gr_top_block_sptr *", 0, 0, (void*)0, 0};
5717 static swig_type_info _swigt__p_boost__shared_ptrT_howto_square2_ff_t = {"_p_boost__shared_ptrT_howto_square2_ff_t", "boost::shared_ptr< howto_square2_ff > *|howto_square2_ff_sptr *", 0, 0, (void*)0, 0};
5718 static swig_type_info _swigt__p_boost__shared_ptrT_howto_square_ff_t = {"_p_boost__shared_ptrT_howto_square_ff_t", "boost::shared_ptr< howto_square_ff > *|howto_square_ff_sptr *", 0, 0, (void*)0, 0};
5719 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
5720 static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
5721 static swig_type_info _swigt__p_gr_basic_block = {"_p_gr_basic_block", "gr_basic_block *", 0, 0, (void*)0, 0};
5722 static swig_type_info _swigt__p_gr_sync_decimator = {"_p_gr_sync_decimator", 0, 0, 0, 0, 0};
5723 static swig_type_info _swigt__p_gr_hier_block2 = {"_p_gr_hier_block2", 0, 0, 0, 0, 0};
5724 static swig_type_info _swigt__p_gr_sync_interpolator = {"_p_gr_sync_interpolator", 0, 0, 0, 0, 0};
5725 static swig_type_info _swigt__p_gr_top_block = {"_p_gr_top_block", 0, 0, 0, 0, 0};
5726 static swig_type_info _swigt__p_gr_block = {"_p_gr_block", "gr_block *", 0, 0, (void*)0, 0};
5727 static swig_type_info _swigt__p_gr_sync_block = {"_p_gr_sync_block", "gr_sync_block *", 0, 0, (void*)0, 0};
5728 static swig_type_info _swigt__p_gruel__rt_status_t = {"_p_gruel__rt_status_t", "enum gruel::rt_status_t *|gruel::rt_status_t *|gr_rt_status_t *", 0, 0, (void*)0, 0};
5729 static swig_type_info _swigt__p_howto_square2_ff = {"_p_howto_square2_ff", "howto_square2_ff *", 0, 0, (void*)0, 0};
5730 static swig_type_info _swigt__p_howto_square_ff = {"_p_howto_square_ff", "howto_square_ff *", 0, 0, (void*)0, 0};
5731 static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
5732 static swig_type_info _swigt__p_std__complexT_double_t = {"_p_std__complexT_double_t", "gr_complexd *|std::complex< double > *", 0, 0, (void*)0, 0};
5733 static swig_type_info _swigt__p_std__complexT_float_t = {"_p_std__complexT_float_t", "std::complex< float > *|gr_complex *", 0, 0, (void*)0, 0};
5734 static swig_type_info _swigt__p_std__invalid_argument = {"_p_std__invalid_argument", "std::invalid_argument *", 0, 0, (void*)0, 0};
5735 static swig_type_info _swigt__p_swig__PySwigIterator = {"_p_swig__PySwigIterator", "swig::PySwigIterator *", 0, 0, (void*)0, 0};
5736 static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
5737
5738 static swig_type_info *swig_type_initial[] = {
5739   &_swigt__p_allocator_type,
5740   &_swigt__p_boost__shared_ptrT_gr_basic_block_t,
5741   &_swigt__p_boost__shared_ptrT_gr_block_detail_t,
5742   &_swigt__p_boost__shared_ptrT_gr_block_t,
5743   &_swigt__p_boost__shared_ptrT_gr_buffer_reader_t,
5744   &_swigt__p_boost__shared_ptrT_gr_buffer_t,
5745   &_swigt__p_boost__shared_ptrT_gr_dispatcher_t,
5746   &_swigt__p_boost__shared_ptrT_gr_hier_block2_t,
5747   &_swigt__p_boost__shared_ptrT_gr_io_signature_t,
5748   &_swigt__p_boost__shared_ptrT_gr_message_t,
5749   &_swigt__p_boost__shared_ptrT_gr_msg_queue_t,
5750   &_swigt__p_boost__shared_ptrT_gr_single_threaded_scheduler_t,
5751   &_swigt__p_boost__shared_ptrT_gr_top_block_t,
5752   &_swigt__p_boost__shared_ptrT_howto_square2_ff_t,
5753   &_swigt__p_boost__shared_ptrT_howto_square_ff_t,
5754   &_swigt__p_char,
5755   &_swigt__p_difference_type,
5756   &_swigt__p_gr_basic_block,
5757   &_swigt__p_gr_block,
5758   &_swigt__p_gr_hier_block2,
5759   &_swigt__p_gr_sync_block,
5760   &_swigt__p_gr_sync_decimator,
5761   &_swigt__p_gr_sync_interpolator,
5762   &_swigt__p_gr_top_block,
5763   &_swigt__p_gruel__rt_status_t,
5764   &_swigt__p_howto_square2_ff,
5765   &_swigt__p_howto_square_ff,
5766   &_swigt__p_size_type,
5767   &_swigt__p_std__complexT_double_t,
5768   &_swigt__p_std__complexT_float_t,
5769   &_swigt__p_std__invalid_argument,
5770   &_swigt__p_swig__PySwigIterator,
5771   &_swigt__p_value_type,
5772 };
5773
5774 static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
5775 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_basic_block_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_basic_block_t, 0, 0, 0},{0, 0, 0, 0}};
5776 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_block_detail_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_block_detail_t, 0, 0, 0},{0, 0, 0, 0}};
5777 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_block_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_block_t, 0, 0, 0},{0, 0, 0, 0}};
5778 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_buffer_reader_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_buffer_reader_t, 0, 0, 0},{0, 0, 0, 0}};
5779 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_buffer_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_buffer_t, 0, 0, 0},{0, 0, 0, 0}};
5780 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_dispatcher_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_dispatcher_t, 0, 0, 0},{0, 0, 0, 0}};
5781 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_hier_block2_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_hier_block2_t, 0, 0, 0},{0, 0, 0, 0}};
5782 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_io_signature_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_io_signature_t, 0, 0, 0},{0, 0, 0, 0}};
5783 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_message_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_message_t, 0, 0, 0},{0, 0, 0, 0}};
5784 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_msg_queue_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_msg_queue_t, 0, 0, 0},{0, 0, 0, 0}};
5785 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_single_threaded_scheduler_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_single_threaded_scheduler_t, 0, 0, 0},{0, 0, 0, 0}};
5786 static swig_cast_info _swigc__p_boost__shared_ptrT_gr_top_block_t[] = {  {&_swigt__p_boost__shared_ptrT_gr_top_block_t, 0, 0, 0},{0, 0, 0, 0}};
5787 static swig_cast_info _swigc__p_boost__shared_ptrT_howto_square2_ff_t[] = {  {&_swigt__p_boost__shared_ptrT_howto_square2_ff_t, 0, 0, 0},{0, 0, 0, 0}};
5788 static swig_cast_info _swigc__p_boost__shared_ptrT_howto_square_ff_t[] = {  {&_swigt__p_boost__shared_ptrT_howto_square_ff_t, 0, 0, 0},{0, 0, 0, 0}};
5789 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
5790 static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
5791 static swig_cast_info _swigc__p_gr_sync_decimator[] = {{&_swigt__p_gr_sync_decimator, 0, 0, 0},{0, 0, 0, 0}};
5792 static swig_cast_info _swigc__p_gr_hier_block2[] = {{&_swigt__p_gr_hier_block2, 0, 0, 0},{0, 0, 0, 0}};
5793 static swig_cast_info _swigc__p_gr_sync_interpolator[] = {{&_swigt__p_gr_sync_interpolator, 0, 0, 0},{0, 0, 0, 0}};
5794 static swig_cast_info _swigc__p_gr_top_block[] = {{&_swigt__p_gr_top_block, 0, 0, 0},{0, 0, 0, 0}};
5795 static swig_cast_info _swigc__p_gr_basic_block[] = {  {&_swigt__p_howto_square2_ff, _p_howto_square2_ffTo_p_gr_basic_block, 0, 0},  {&_swigt__p_gr_sync_decimator, _p_gr_sync_decimatorTo_p_gr_basic_block, 0, 0},  {&_swigt__p_gr_basic_block, 0, 0, 0},  {&_swigt__p_gr_hier_block2, _p_gr_hier_block2To_p_gr_basic_block, 0, 0},  {&_swigt__p_gr_sync_block, _p_gr_sync_blockTo_p_gr_basic_block, 0, 0},  {&_swigt__p_gr_sync_interpolator, _p_gr_sync_interpolatorTo_p_gr_basic_block, 0, 0},  {&_swigt__p_gr_block, _p_gr_blockTo_p_gr_basic_block, 0, 0},  {&_swigt__p_howto_square_ff, _p_howto_square_ffTo_p_gr_basic_block, 0, 0},  {&_swigt__p_gr_top_block, _p_gr_top_blockTo_p_gr_basic_block, 0, 0},{0, 0, 0, 0}};
5796 static swig_cast_info _swigc__p_gr_block[] = {  {&_swigt__p_howto_square2_ff, _p_howto_square2_ffTo_p_gr_block, 0, 0},  {&_swigt__p_gr_sync_decimator, _p_gr_sync_decimatorTo_p_gr_block, 0, 0},  {&_swigt__p_gr_sync_block, _p_gr_sync_blockTo_p_gr_block, 0, 0},  {&_swigt__p_gr_block, 0, 0, 0},  {&_swigt__p_gr_sync_interpolator, _p_gr_sync_interpolatorTo_p_gr_block, 0, 0},  {&_swigt__p_howto_square_ff, _p_howto_square_ffTo_p_gr_block, 0, 0},{0, 0, 0, 0}};
5797 static swig_cast_info _swigc__p_gr_sync_block[] = {  {&_swigt__p_howto_square2_ff, _p_howto_square2_ffTo_p_gr_sync_block, 0, 0},  {&_swigt__p_gr_sync_decimator, _p_gr_sync_decimatorTo_p_gr_sync_block, 0, 0},  {&_swigt__p_gr_sync_block, 0, 0, 0},  {&_swigt__p_gr_sync_interpolator, _p_gr_sync_interpolatorTo_p_gr_sync_block, 0, 0},{0, 0, 0, 0}};
5798 static swig_cast_info _swigc__p_gruel__rt_status_t[] = {  {&_swigt__p_gruel__rt_status_t, 0, 0, 0},{0, 0, 0, 0}};
5799 static swig_cast_info _swigc__p_howto_square2_ff[] = {  {&_swigt__p_howto_square2_ff, 0, 0, 0},{0, 0, 0, 0}};
5800 static swig_cast_info _swigc__p_howto_square_ff[] = {  {&_swigt__p_howto_square_ff, 0, 0, 0},{0, 0, 0, 0}};
5801 static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
5802 static swig_cast_info _swigc__p_std__complexT_double_t[] = {  {&_swigt__p_std__complexT_double_t, 0, 0, 0},{0, 0, 0, 0}};
5803 static swig_cast_info _swigc__p_std__complexT_float_t[] = {  {&_swigt__p_std__complexT_float_t, 0, 0, 0},{0, 0, 0, 0}};
5804 static swig_cast_info _swigc__p_std__invalid_argument[] = {  {&_swigt__p_std__invalid_argument, 0, 0, 0},{0, 0, 0, 0}};
5805 static swig_cast_info _swigc__p_swig__PySwigIterator[] = {  {&_swigt__p_swig__PySwigIterator, 0, 0, 0},{0, 0, 0, 0}};
5806 static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
5807
5808 static swig_cast_info *swig_cast_initial[] = {
5809   _swigc__p_allocator_type,
5810   _swigc__p_boost__shared_ptrT_gr_basic_block_t,
5811   _swigc__p_boost__shared_ptrT_gr_block_detail_t,
5812   _swigc__p_boost__shared_ptrT_gr_block_t,
5813   _swigc__p_boost__shared_ptrT_gr_buffer_reader_t,
5814   _swigc__p_boost__shared_ptrT_gr_buffer_t,
5815   _swigc__p_boost__shared_ptrT_gr_dispatcher_t,
5816   _swigc__p_boost__shared_ptrT_gr_hier_block2_t,
5817   _swigc__p_boost__shared_ptrT_gr_io_signature_t,
5818   _swigc__p_boost__shared_ptrT_gr_message_t,
5819   _swigc__p_boost__shared_ptrT_gr_msg_queue_t,
5820   _swigc__p_boost__shared_ptrT_gr_single_threaded_scheduler_t,
5821   _swigc__p_boost__shared_ptrT_gr_top_block_t,
5822   _swigc__p_boost__shared_ptrT_howto_square2_ff_t,
5823   _swigc__p_boost__shared_ptrT_howto_square_ff_t,
5824   _swigc__p_char,
5825   _swigc__p_difference_type,
5826   _swigc__p_gr_basic_block,
5827   _swigc__p_gr_block,
5828   _swigc__p_gr_hier_block2,
5829   _swigc__p_gr_sync_block,
5830   _swigc__p_gr_sync_decimator,
5831   _swigc__p_gr_sync_interpolator,
5832   _swigc__p_gr_top_block,
5833   _swigc__p_gruel__rt_status_t,
5834   _swigc__p_howto_square2_ff,
5835   _swigc__p_howto_square_ff,
5836   _swigc__p_size_type,
5837   _swigc__p_std__complexT_double_t,
5838   _swigc__p_std__complexT_float_t,
5839   _swigc__p_std__invalid_argument,
5840   _swigc__p_swig__PySwigIterator,
5841   _swigc__p_value_type,
5842 };
5843
5844
5845 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
5846
5847 static swig_const_info swig_const_table[] = {
5848 {0, 0, 0, 0.0, 0, 0}};
5849
5850 #ifdef __cplusplus
5851 }
5852 #endif
5853 /* -----------------------------------------------------------------------------
5854  * Type initialization:
5855  * This problem is tough by the requirement that no dynamic
5856  * memory is used. Also, since swig_type_info structures store pointers to
5857  * swig_cast_info structures and swig_cast_info structures store pointers back
5858  * to swig_type_info structures, we need some lookup code at initialization.
5859  * The idea is that swig generates all the structures that are needed.
5860  * The runtime then collects these partially filled structures.
5861  * The SWIG_InitializeModule function takes these initial arrays out of
5862  * swig_module, and does all the lookup, filling in the swig_module.types
5863  * array with the correct data and linking the correct swig_cast_info
5864  * structures together.
5865  *
5866  * The generated swig_type_info structures are assigned staticly to an initial
5867  * array. We just loop through that array, and handle each type individually.
5868  * First we lookup if this type has been already loaded, and if so, use the
5869  * loaded structure instead of the generated one. Then we have to fill in the
5870  * cast linked list. The cast data is initially stored in something like a
5871  * two-dimensional array. Each row corresponds to a type (there are the same
5872  * number of rows as there are in the swig_type_initial array). Each entry in
5873  * a column is one of the swig_cast_info structures for that type.
5874  * The cast_initial array is actually an array of arrays, because each row has
5875  * a variable number of columns. So to actually build the cast linked list,
5876  * we find the array of casts associated with the type, and loop through it
5877  * adding the casts to the list. The one last trick we need to do is making
5878  * sure the type pointer in the swig_cast_info struct is correct.
5879  *
5880  * First off, we lookup the cast->type name to see if it is already loaded.
5881  * There are three cases to handle:
5882  *  1) If the cast->type has already been loaded AND the type we are adding
5883  *     casting info to has not been loaded (it is in this module), THEN we
5884  *     replace the cast->type pointer with the type pointer that has already
5885  *     been loaded.
5886  *  2) If BOTH types (the one we are adding casting info to, and the
5887  *     cast->type) are loaded, THEN the cast info has already been loaded by
5888  *     the previous module so we just ignore it.
5889  *  3) Finally, if cast->type has not already been loaded, then we add that
5890  *     swig_cast_info to the linked list (because the cast->type) pointer will
5891  *     be correct.
5892  * ----------------------------------------------------------------------------- */
5893
5894 #ifdef __cplusplus
5895 extern "C" {
5896 #if 0
5897 } /* c-mode */
5898 #endif
5899 #endif
5900
5901 #if 0
5902 #define SWIGRUNTIME_DEBUG
5903 #endif
5904
5905
5906 SWIGRUNTIME void
5907 SWIG_InitializeModule(void *clientdata) {
5908   size_t i;
5909   swig_module_info *module_head, *iter;
5910   int found, init;
5911
5912   clientdata = clientdata;
5913
5914   /* check to see if the circular list has been setup, if not, set it up */
5915   if (swig_module.next==0) {
5916     /* Initialize the swig_module */
5917     swig_module.type_initial = swig_type_initial;
5918     swig_module.cast_initial = swig_cast_initial;
5919     swig_module.next = &swig_module;
5920     init = 1;
5921   } else {
5922     init = 0;
5923   }
5924
5925   /* Try and load any already created modules */
5926   module_head = SWIG_GetModule(clientdata);
5927   if (!module_head) {
5928     /* This is the first module loaded for this interpreter */
5929     /* so set the swig module into the interpreter */
5930     SWIG_SetModule(clientdata, &swig_module);
5931     module_head = &swig_module;
5932   } else {
5933     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
5934     found=0;
5935     iter=module_head;
5936     do {
5937       if (iter==&swig_module) {
5938         found=1;
5939         break;
5940       }
5941       iter=iter->next;
5942     } while (iter!= module_head);
5943
5944     /* if the is found in the list, then all is done and we may leave */
5945     if (found) return;
5946     /* otherwise we must add out module into the list */
5947     swig_module.next = module_head->next;
5948     module_head->next = &swig_module;
5949   }
5950
5951   /* When multiple interpeters are used, a module could have already been initialized in
5952        a different interpreter, but not yet have a pointer in this interpreter.
5953        In this case, we do not want to continue adding types... everything should be
5954        set up already */
5955   if (init == 0) return;
5956
5957   /* Now work on filling in swig_module.types */
5958 #ifdef SWIGRUNTIME_DEBUG
5959   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
5960 #endif
5961   for (i = 0; i < swig_module.size; ++i) {
5962     swig_type_info *type = 0;
5963     swig_type_info *ret;
5964     swig_cast_info *cast;
5965
5966 #ifdef SWIGRUNTIME_DEBUG
5967     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
5968 #endif
5969
5970     /* if there is another module already loaded */
5971     if (swig_module.next != &swig_module) {
5972       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
5973     }
5974     if (type) {
5975       /* Overwrite clientdata field */
5976 #ifdef SWIGRUNTIME_DEBUG
5977       printf("SWIG_InitializeModule: found type %s\n", type->name);
5978 #endif
5979       if (swig_module.type_initial[i]->clientdata) {
5980         type->clientdata = swig_module.type_initial[i]->clientdata;
5981 #ifdef SWIGRUNTIME_DEBUG
5982         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
5983 #endif
5984       }
5985     } else {
5986       type = swig_module.type_initial[i];
5987     }
5988
5989     /* Insert casting types */
5990     cast = swig_module.cast_initial[i];
5991     while (cast->type) {
5992       /* Don't need to add information already in the list */
5993       ret = 0;
5994 #ifdef SWIGRUNTIME_DEBUG
5995       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
5996 #endif
5997       if (swig_module.next != &swig_module) {
5998         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
5999 #ifdef SWIGRUNTIME_DEBUG
6000         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
6001 #endif
6002       }
6003       if (ret) {
6004         if (type == swig_module.type_initial[i]) {
6005 #ifdef SWIGRUNTIME_DEBUG
6006           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
6007 #endif
6008           cast->type = ret;
6009           ret = 0;
6010         } else {
6011           /* Check for casting already in the list */
6012           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
6013 #ifdef SWIGRUNTIME_DEBUG
6014           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
6015 #endif
6016           if (!ocast) ret = 0;
6017         }
6018       }
6019
6020       if (!ret) {
6021 #ifdef SWIGRUNTIME_DEBUG
6022         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
6023 #endif
6024         if (type->cast) {
6025           type->cast->prev = cast;
6026           cast->next = type->cast;
6027         }
6028         type->cast = cast;
6029       }
6030       cast++;
6031     }
6032     /* Set entry in modules->types array equal to the type */
6033     swig_module.types[i] = type;
6034   }
6035   swig_module.types[i] = 0;
6036
6037 #ifdef SWIGRUNTIME_DEBUG
6038   printf("**** SWIG_InitializeModule: Cast List ******\n");
6039   for (i = 0; i < swig_module.size; ++i) {
6040     int j = 0;
6041     swig_cast_info *cast = swig_module.cast_initial[i];
6042     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6043     while (cast->type) {
6044       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
6045       cast++;
6046       ++j;
6047     }
6048     printf("---- Total casts: %d\n",j);
6049   }
6050   printf("**** SWIG_InitializeModule: Cast List ******\n");
6051 #endif
6052 }
6053
6054 /* This function will propagate the clientdata field of type to
6055 * any new swig_type_info structures that have been added into the list
6056 * of equivalent types.  It is like calling
6057 * SWIG_TypeClientData(type, clientdata) a second time.
6058 */
6059 SWIGRUNTIME void
6060 SWIG_PropagateClientData(void) {
6061   size_t i;
6062   swig_cast_info *equiv;
6063   static int init_run = 0;
6064
6065   if (init_run) return;
6066   init_run = 1;
6067
6068   for (i = 0; i < swig_module.size; i++) {
6069     if (swig_module.types[i]->clientdata) {
6070       equiv = swig_module.types[i]->cast;
6071       while (equiv) {
6072         if (!equiv->converter) {
6073           if (equiv->type && !equiv->type->clientdata)
6074           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
6075         }
6076         equiv = equiv->next;
6077       }
6078     }
6079   }
6080 }
6081
6082 #ifdef __cplusplus
6083 #if 0
6084 {
6085   /* c-mode */
6086 #endif
6087 }
6088 #endif
6089
6090
6091
6092 #ifdef __cplusplus
6093 extern "C" {
6094 #endif
6095
6096   /* Python-specific SWIG API */
6097 #define SWIG_newvarlink()                             SWIG_Python_newvarlink()
6098 #define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
6099 #define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
6100
6101   /* -----------------------------------------------------------------------------
6102    * global variable support code.
6103    * ----------------------------------------------------------------------------- */
6104
6105   typedef struct swig_globalvar {
6106     char       *name;                  /* Name of global variable */
6107     PyObject *(*get_attr)(void);       /* Return the current value */
6108     int       (*set_attr)(PyObject *); /* Set the value */
6109     struct swig_globalvar *next;
6110   } swig_globalvar;
6111
6112   typedef struct swig_varlinkobject {
6113     PyObject_HEAD
6114     swig_globalvar *vars;
6115   } swig_varlinkobject;
6116
6117   SWIGINTERN PyObject *
6118   swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
6119     return PyString_FromString("<Swig global variables>");
6120   }
6121
6122   SWIGINTERN PyObject *
6123   swig_varlink_str(swig_varlinkobject *v) {
6124     PyObject *str = PyString_FromString("(");
6125     swig_globalvar  *var;
6126     for (var = v->vars; var; var=var->next) {
6127       PyString_ConcatAndDel(&str,PyString_FromString(var->name));
6128       if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
6129     }
6130     PyString_ConcatAndDel(&str,PyString_FromString(")"));
6131     return str;
6132   }
6133
6134   SWIGINTERN int
6135   swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
6136     PyObject *str = swig_varlink_str(v);
6137     fprintf(fp,"Swig global variables ");
6138     fprintf(fp,"%s\n", PyString_AsString(str));
6139     Py_DECREF(str);
6140     return 0;
6141   }
6142
6143   SWIGINTERN void
6144   swig_varlink_dealloc(swig_varlinkobject *v) {
6145     swig_globalvar *var = v->vars;
6146     while (var) {
6147       swig_globalvar *n = var->next;
6148       free(var->name);
6149       free(var);
6150       var = n;
6151     }
6152   }
6153
6154   SWIGINTERN PyObject *
6155   swig_varlink_getattr(swig_varlinkobject *v, char *n) {
6156     PyObject *res = NULL;
6157     swig_globalvar *var = v->vars;
6158     while (var) {
6159       if (strcmp(var->name,n) == 0) {
6160         res = (*var->get_attr)();
6161         break;
6162       }
6163       var = var->next;
6164     }
6165     if (res == NULL && !PyErr_Occurred()) {
6166       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6167     }
6168     return res;
6169   }
6170
6171   SWIGINTERN int
6172   swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
6173     int res = 1;
6174     swig_globalvar *var = v->vars;
6175     while (var) {
6176       if (strcmp(var->name,n) == 0) {
6177         res = (*var->set_attr)(p);
6178         break;
6179       }
6180       var = var->next;
6181     }
6182     if (res == 1 && !PyErr_Occurred()) {
6183       PyErr_SetString(PyExc_NameError,"Unknown C global variable");
6184     }
6185     return res;
6186   }
6187
6188   SWIGINTERN PyTypeObject*
6189   swig_varlink_type(void) {
6190     static char varlink__doc__[] = "Swig var link object";
6191     static PyTypeObject varlink_type;
6192     static int type_init = 0;
6193     if (!type_init) {
6194       const PyTypeObject tmp
6195       = {
6196         PyObject_HEAD_INIT(NULL)
6197         0,                                  /* Number of items in variable part (ob_size) */
6198         (char *)"swigvarlink",              /* Type name (tp_name) */
6199         sizeof(swig_varlinkobject),         /* Basic size (tp_basicsize) */
6200         0,                                  /* Itemsize (tp_itemsize) */
6201         (destructor) swig_varlink_dealloc,   /* Deallocator (tp_dealloc) */
6202         (printfunc) swig_varlink_print,     /* Print (tp_print) */
6203         (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
6204         (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
6205         0,                                  /* tp_compare */
6206         (reprfunc) swig_varlink_repr,       /* tp_repr */
6207         0,                                  /* tp_as_number */
6208         0,                                  /* tp_as_sequence */
6209         0,                                  /* tp_as_mapping */
6210         0,                                  /* tp_hash */
6211         0,                                  /* tp_call */
6212         (reprfunc)swig_varlink_str,        /* tp_str */
6213         0,                                  /* tp_getattro */
6214         0,                                  /* tp_setattro */
6215         0,                                  /* tp_as_buffer */
6216         0,                                  /* tp_flags */
6217         varlink__doc__,                     /* tp_doc */
6218         0,                                  /* tp_traverse */
6219         0,                                  /* tp_clear */
6220         0,                                  /* tp_richcompare */
6221         0,                                  /* tp_weaklistoffset */
6222 #if PY_VERSION_HEX >= 0x02020000
6223         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
6224 #endif
6225 #if PY_VERSION_HEX >= 0x02030000
6226         0,                                  /* tp_del */
6227 #endif
6228 #ifdef COUNT_ALLOCS
6229         0,0,0,0                             /* tp_alloc -> tp_next */
6230 #endif
6231       };
6232       varlink_type = tmp;
6233       varlink_type.ob_type = &PyType_Type;
6234       type_init = 1;
6235     }
6236     return &varlink_type;
6237   }
6238
6239   /* Create a variable linking object for use later */
6240   SWIGINTERN PyObject *
6241   SWIG_Python_newvarlink(void) {
6242     swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
6243     if (result) {
6244       result->vars = 0;
6245     }
6246     return ((PyObject*) result);
6247   }
6248
6249   SWIGINTERN void
6250   SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
6251     swig_varlinkobject *v = (swig_varlinkobject *) p;
6252     swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
6253     if (gv) {
6254       size_t size = strlen(name)+1;
6255       gv->name = (char *)malloc(size);
6256       if (gv->name) {
6257         strncpy(gv->name,name,size);
6258         gv->get_attr = get_attr;
6259         gv->set_attr = set_attr;
6260         gv->next = v->vars;
6261       }
6262     }
6263     v->vars = gv;
6264   }
6265
6266   SWIGINTERN PyObject *
6267   SWIG_globals(void) {
6268     static PyObject *_SWIG_globals = 0;
6269     if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
6270     return _SWIG_globals;
6271   }
6272
6273   /* -----------------------------------------------------------------------------
6274    * constants/methods manipulation
6275    * ----------------------------------------------------------------------------- */
6276
6277   /* Install Constants */
6278   SWIGINTERN void
6279   SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
6280     PyObject *obj = 0;
6281     size_t i;
6282     for (i = 0; constants[i].type; ++i) {
6283       switch(constants[i].type) {
6284       case SWIG_PY_POINTER:
6285         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
6286         break;
6287       case SWIG_PY_BINARY:
6288         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
6289         break;
6290       default:
6291         obj = 0;
6292         break;
6293       }
6294       if (obj) {
6295         PyDict_SetItemString(d, constants[i].name, obj);
6296         Py_DECREF(obj);
6297       }
6298     }
6299   }
6300
6301   /* -----------------------------------------------------------------------------*/
6302   /* Fix SwigMethods to carry the callback ptrs when needed */
6303   /* -----------------------------------------------------------------------------*/
6304
6305   SWIGINTERN void
6306   SWIG_Python_FixMethods(PyMethodDef *methods,
6307     swig_const_info *const_table,
6308     swig_type_info **types,
6309     swig_type_info **types_initial) {
6310     size_t i;
6311     for (i = 0; methods[i].ml_name; ++i) {
6312       const char *c = methods[i].ml_doc;
6313       if (c && (c = strstr(c, "swig_ptr: "))) {
6314         int j;
6315         swig_const_info *ci = 0;
6316         const char *name = c + 10;
6317         for (j = 0; const_table[j].type; ++j) {
6318           if (strncmp(const_table[j].name, name,
6319               strlen(const_table[j].name)) == 0) {
6320             ci = &(const_table[j]);
6321             break;
6322           }
6323         }
6324         if (ci) {
6325           size_t shift = (ci->ptype) - types;
6326           swig_type_info *ty = types_initial[shift];
6327           size_t ldoc = (c - methods[i].ml_doc);
6328           size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
6329           char *ndoc = (char*)malloc(ldoc + lptr + 10);
6330           if (ndoc) {
6331             char *buff = ndoc;
6332             void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
6333             if (ptr) {
6334               strncpy(buff, methods[i].ml_doc, ldoc);
6335               buff += ldoc;
6336               strncpy(buff, "swig_ptr: ", 10);
6337               buff += 10;
6338               SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
6339               methods[i].ml_doc = ndoc;
6340             }
6341           }
6342         }
6343       }
6344     }
6345   }
6346
6347 #ifdef __cplusplus
6348 }
6349 #endif
6350
6351 /* -----------------------------------------------------------------------------*
6352  *  Partial Init method
6353  * -----------------------------------------------------------------------------*/
6354
6355 #ifdef __cplusplus
6356 extern "C"
6357 #endif
6358 SWIGEXPORT void SWIG_init(void) {
6359   PyObject *m, *d;
6360
6361   /* Fix SwigMethods to carry the callback ptrs when needed */
6362   SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
6363
6364   m = Py_InitModule((char *) SWIG_name, SwigMethods);
6365   d = PyModule_GetDict(m);
6366
6367   SWIG_InitializeModule(0);
6368   SWIG_InstallConstants(d,swig_const_table);
6369
6370
6371   SWIG_Python_SetConstant(d, "sizeof_char",SWIG_From_int(static_cast< int >(sizeof(char))));
6372   SWIG_Python_SetConstant(d, "sizeof_short",SWIG_From_int(static_cast< int >(sizeof(short))));
6373   SWIG_Python_SetConstant(d, "sizeof_int",SWIG_From_int(static_cast< int >(sizeof(int))));
6374   SWIG_Python_SetConstant(d, "sizeof_float",SWIG_From_int(static_cast< int >(sizeof(float))));
6375   SWIG_Python_SetConstant(d, "sizeof_double",SWIG_From_int(static_cast< int >(sizeof(double))));
6376   SWIG_Python_SetConstant(d, "sizeof_gr_complex",SWIG_From_int(static_cast< int >(sizeof(gr_complex))));
6377 }
6378