LCOV - code coverage report
Current view: top level - build-llvm/tools/lldb/scripts - LLDBWrapPython.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 17244 45484 37.9 %
Date: 2017-09-14 15:23:50 Functions: 952 2114 45.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* ----------------------------------------------------------------------------
       2             :  * This file was automatically generated by SWIG (http://www.swig.org).
       3             :  * Version 3.0.12
       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             : 
      12             : #ifndef SWIGPYTHON
      13             : #define SWIGPYTHON
      14             : #endif
      15             : 
      16             : #define SWIG_PYTHON_THREADS
      17             : #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
      18             : 
      19             : 
      20             : #ifdef __cplusplus
      21             : /* SwigValueWrapper is described in swig.swg */
      22        4213 : template<typename T> class SwigValueWrapper {
      23             :   struct SwigMovePointer {
      24             :     T *ptr;
      25        8426 :     SwigMovePointer(T *p) : ptr(p) { }
      26        8426 :     ~SwigMovePointer() { delete ptr; }
      27        4213 :     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
      28             :   } pointer;
      29             :   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
      30             :   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
      31             : public:
      32        8426 :   SwigValueWrapper() : pointer(0) { }
      33        8426 :   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
      34        4213 :   operator T&() const { return *pointer.ptr; }
      35             :   T *operator&() { return pointer.ptr; }
      36             : };
      37             : 
      38             : template <typename T> T SwigValueInit() {
      39             :   return T();
      40             : }
      41             : #endif
      42             : 
      43             : /* -----------------------------------------------------------------------------
      44             :  *  This section contains generic SWIG labels for method/variable
      45             :  *  declarations/attributes, and other compiler dependent labels.
      46             :  * ----------------------------------------------------------------------------- */
      47             : 
      48             : /* template workaround for compilers that cannot correctly implement the C++ standard */
      49             : #ifndef SWIGTEMPLATEDISAMBIGUATOR
      50             : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
      51             : #  define SWIGTEMPLATEDISAMBIGUATOR template
      52             : # elif defined(__HP_aCC)
      53             : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
      54             : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
      55             : #  define SWIGTEMPLATEDISAMBIGUATOR template
      56             : # else
      57             : #  define SWIGTEMPLATEDISAMBIGUATOR
      58             : # endif
      59             : #endif
      60             : 
      61             : /* inline attribute */
      62             : #ifndef SWIGINLINE
      63             : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
      64             : #   define SWIGINLINE inline
      65             : # else
      66             : #   define SWIGINLINE
      67             : # endif
      68             : #endif
      69             : 
      70             : /* attribute recognised by some compilers to avoid 'unused' warnings */
      71             : #ifndef SWIGUNUSED
      72             : # if defined(__GNUC__)
      73             : #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
      74             : #     define SWIGUNUSED __attribute__ ((__unused__))
      75             : #   else
      76             : #     define SWIGUNUSED
      77             : #   endif
      78             : # elif defined(__ICC)
      79             : #   define SWIGUNUSED __attribute__ ((__unused__))
      80             : # else
      81             : #   define SWIGUNUSED
      82             : # endif
      83             : #endif
      84             : 
      85             : #ifndef SWIG_MSC_UNSUPPRESS_4505
      86             : # if defined(_MSC_VER)
      87             : #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
      88             : # endif
      89             : #endif
      90             : 
      91             : #ifndef SWIGUNUSEDPARM
      92             : # ifdef __cplusplus
      93             : #   define SWIGUNUSEDPARM(p)
      94             : # else
      95             : #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
      96             : # endif
      97             : #endif
      98             : 
      99             : /* internal SWIG method */
     100             : #ifndef SWIGINTERN
     101             : # define SWIGINTERN static SWIGUNUSED
     102             : #endif
     103             : 
     104             : /* internal inline SWIG method */
     105             : #ifndef SWIGINTERNINLINE
     106             : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
     107             : #endif
     108             : 
     109             : /* exporting methods */
     110             : #if defined(__GNUC__)
     111             : #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
     112             : #    ifndef GCC_HASCLASSVISIBILITY
     113             : #      define GCC_HASCLASSVISIBILITY
     114             : #    endif
     115             : #  endif
     116             : #endif
     117             : 
     118             : #ifndef SWIGEXPORT
     119             : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
     120             : #   if defined(STATIC_LINKED)
     121             : #     define SWIGEXPORT
     122             : #   else
     123             : #     define SWIGEXPORT __declspec(dllexport)
     124             : #   endif
     125             : # else
     126             : #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
     127             : #     define SWIGEXPORT __attribute__ ((visibility("default")))
     128             : #   else
     129             : #     define SWIGEXPORT
     130             : #   endif
     131             : # endif
     132             : #endif
     133             : 
     134             : /* calling conventions for Windows */
     135             : #ifndef SWIGSTDCALL
     136             : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
     137             : #   define SWIGSTDCALL __stdcall
     138             : # else
     139             : #   define SWIGSTDCALL
     140             : # endif
     141             : #endif
     142             : 
     143             : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
     144             : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
     145             : # define _CRT_SECURE_NO_DEPRECATE
     146             : #endif
     147             : 
     148             : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
     149             : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
     150             : # define _SCL_SECURE_NO_DEPRECATE
     151             : #endif
     152             : 
     153             : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
     154             : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
     155             : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
     156             : #endif
     157             : 
     158             : /* Intel's compiler complains if a variable which was never initialised is
     159             :  * cast to void, which is a common idiom which we use to indicate that we
     160             :  * are aware a variable isn't used.  So we just silence that warning.
     161             :  * See: https://github.com/swig/swig/issues/192 for more discussion.
     162             :  */
     163             : #ifdef __INTEL_COMPILER
     164             : # pragma warning disable 592
     165             : #endif
     166             : 
     167             : 
     168             : #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
     169             : /* Use debug wrappers with the Python release dll */
     170             : # undef _DEBUG
     171             : # include <Python.h>
     172             : # define _DEBUG
     173             : #else
     174             : # include <Python.h>
     175             : #endif
     176             : 
     177             : /* -----------------------------------------------------------------------------
     178             :  * swigrun.swg
     179             :  *
     180             :  * This file contains generic C API SWIG runtime support for pointer
     181             :  * type checking.
     182             :  * ----------------------------------------------------------------------------- */
     183             : 
     184             : /* This should only be incremented when either the layout of swig_type_info changes,
     185             :    or for whatever reason, the runtime changes incompatibly */
     186             : #define SWIG_RUNTIME_VERSION "4"
     187             : 
     188             : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
     189             : #ifdef SWIG_TYPE_TABLE
     190             : # define SWIG_QUOTE_STRING(x) #x
     191             : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
     192             : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
     193             : #else
     194             : # define SWIG_TYPE_TABLE_NAME
     195             : #endif
     196             : 
     197             : /*
     198             :   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
     199             :   creating a static or dynamic library from the SWIG runtime code.
     200             :   In 99.9% of the cases, SWIG just needs to declare them as 'static'.
     201             : 
     202             :   But only do this if strictly necessary, ie, if you have problems
     203             :   with your compiler or suchlike.
     204             : */
     205             : 
     206             : #ifndef SWIGRUNTIME
     207             : # define SWIGRUNTIME SWIGINTERN
     208             : #endif
     209             : 
     210             : #ifndef SWIGRUNTIMEINLINE
     211             : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
     212             : #endif
     213             : 
     214             : /*  Generic buffer size */
     215             : #ifndef SWIG_BUFFER_SIZE
     216             : # define SWIG_BUFFER_SIZE 1024
     217             : #endif
     218             : 
     219             : /* Flags for pointer conversions */
     220             : #define SWIG_POINTER_DISOWN        0x1
     221             : #define SWIG_CAST_NEW_MEMORY       0x2
     222             : 
     223             : /* Flags for new pointer objects */
     224             : #define SWIG_POINTER_OWN           0x1
     225             : 
     226             : 
     227             : /*
     228             :    Flags/methods for returning states.
     229             : 
     230             :    The SWIG conversion methods, as ConvertPtr, return an integer
     231             :    that tells if the conversion was successful or not. And if not,
     232             :    an error code can be returned (see swigerrors.swg for the codes).
     233             : 
     234             :    Use the following macros/flags to set or process the returning
     235             :    states.
     236             : 
     237             :    In old versions of SWIG, code such as the following was usually written:
     238             : 
     239             :      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
     240             :        // success code
     241             :      } else {
     242             :        //fail code
     243             :      }
     244             : 
     245             :    Now you can be more explicit:
     246             : 
     247             :     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
     248             :     if (SWIG_IsOK(res)) {
     249             :       // success code
     250             :     } else {
     251             :       // fail code
     252             :     }
     253             : 
     254             :    which is the same really, but now you can also do
     255             : 
     256             :     Type *ptr;
     257             :     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
     258             :     if (SWIG_IsOK(res)) {
     259             :       // success code
     260             :       if (SWIG_IsNewObj(res) {
     261             :         ...
     262             :         delete *ptr;
     263             :       } else {
     264             :         ...
     265             :       }
     266             :     } else {
     267             :       // fail code
     268             :     }
     269             : 
     270             :    I.e., now SWIG_ConvertPtr can return new objects and you can
     271             :    identify the case and take care of the deallocation. Of course that
     272             :    also requires SWIG_ConvertPtr to return new result values, such as
     273             : 
     274             :       int SWIG_ConvertPtr(obj, ptr,...) {
     275             :         if (<obj is ok>) {
     276             :           if (<need new object>) {
     277             :             *ptr = <ptr to new allocated object>;
     278             :             return SWIG_NEWOBJ;
     279             :           } else {
     280             :             *ptr = <ptr to old object>;
     281             :             return SWIG_OLDOBJ;
     282             :           }
     283             :         } else {
     284             :           return SWIG_BADOBJ;
     285             :         }
     286             :       }
     287             : 
     288             :    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
     289             :    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
     290             :    SWIG errors code.
     291             : 
     292             :    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
     293             :    allows to return the 'cast rank', for example, if you have this
     294             : 
     295             :        int food(double)
     296             :        int fooi(int);
     297             : 
     298             :    and you call
     299             : 
     300             :       food(1)   // cast rank '1'  (1 -> 1.0)
     301             :       fooi(1)   // cast rank '0'
     302             : 
     303             :    just use the SWIG_AddCast()/SWIG_CheckState()
     304             : */
     305             : 
     306             : #define SWIG_OK                    (0)
     307             : #define SWIG_ERROR                 (-1)
     308             : #define SWIG_IsOK(r)               (r >= 0)
     309             : #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
     310             : 
     311             : /* The CastRankLimit says how many bits are used for the cast rank */
     312             : #define SWIG_CASTRANKLIMIT         (1 << 8)
     313             : /* The NewMask denotes the object was created (using new/malloc) */
     314             : #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
     315             : /* The TmpMask is for in/out typemaps that use temporal objects */
     316             : #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
     317             : /* Simple returning values */
     318             : #define SWIG_BADOBJ                (SWIG_ERROR)
     319             : #define SWIG_OLDOBJ                (SWIG_OK)
     320             : #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
     321             : #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
     322             : /* Check, add and del mask methods */
     323             : #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
     324             : #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
     325             : #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
     326             : #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
     327             : #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
     328             : #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
     329             : 
     330             : /* Cast-Rank Mode */
     331             : #if defined(SWIG_CASTRANK_MODE)
     332             : #  ifndef SWIG_TypeRank
     333             : #    define SWIG_TypeRank             unsigned long
     334             : #  endif
     335             : #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
     336             : #    define SWIG_MAXCASTRANK          (2)
     337             : #  endif
     338             : #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
     339             : #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
     340             : SWIGINTERNINLINE int SWIG_AddCast(int r) {
     341             :   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
     342             : }
     343             : SWIGINTERNINLINE int SWIG_CheckState(int r) {
     344             :   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
     345             : }
     346             : #else /* no cast-rank mode */
     347             : #  define SWIG_AddCast(r) (r)
     348             : #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
     349             : #endif
     350             : 
     351             : 
     352             : #include <string.h>
     353             : 
     354             : #ifdef __cplusplus
     355             : extern "C" {
     356             : #endif
     357             : 
     358             : typedef void *(*swig_converter_func)(void *, int *);
     359             : typedef struct swig_type_info *(*swig_dycast_func)(void **);
     360             : 
     361             : /* Structure to store information on one type */
     362             : typedef struct swig_type_info {
     363             :   const char             *name;                 /* mangled name of this type */
     364             :   const char             *str;                  /* human readable name of this type */
     365             :   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
     366             :   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
     367             :   void                   *clientdata;           /* language specific type data */
     368             :   int                    owndata;               /* flag if the structure owns the clientdata */
     369             : } swig_type_info;
     370             : 
     371             : /* Structure to store a type and conversion function used for casting */
     372             : typedef struct swig_cast_info {
     373             :   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
     374             :   swig_converter_func     converter;            /* function to cast the void pointers */
     375             :   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
     376             :   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
     377             : } swig_cast_info;
     378             : 
     379             : /* Structure used to store module information
     380             :  * Each module generates one structure like this, and the runtime collects
     381             :  * all of these structures and stores them in a circularly linked list.*/
     382             : typedef struct swig_module_info {
     383             :   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
     384             :   size_t                 size;                  /* Number of types in this module */
     385             :   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
     386             :   swig_type_info         **type_initial;        /* Array of initially generated type structures */
     387             :   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
     388             :   void                    *clientdata;          /* Language specific module data */
     389             : } swig_module_info;
     390             : 
     391             : /*
     392             :   Compare two type names skipping the space characters, therefore
     393             :   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
     394             : 
     395             :   Return 0 when the two name types are equivalent, as in
     396             :   strncmp, but skipping ' '.
     397             : */
     398             : SWIGRUNTIME int
     399           0 : SWIG_TypeNameComp(const char *f1, const char *l1,
     400             :                   const char *f2, const char *l2) {
     401           0 :   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
     402           0 :     while ((*f1 == ' ') && (f1 != l1)) ++f1;
     403           0 :     while ((*f2 == ' ') && (f2 != l2)) ++f2;
     404           0 :     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
     405             :   }
     406           0 :   return (int)((l1 - f1) - (l2 - f2));
     407             : }
     408             : 
     409             : /*
     410             :   Check type equivalence in a name list like <name1>|<name2>|...
     411             :   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
     412             : */
     413             : SWIGRUNTIME int
     414           0 : SWIG_TypeCmp(const char *nb, const char *tb) {
     415           0 :   int equiv = 1;
     416           0 :   const char* te = tb + strlen(tb);
     417           0 :   const char* ne = nb;
     418           0 :   while (equiv != 0 && *ne) {
     419           0 :     for (nb = ne; *ne; ++ne) {
     420           0 :       if (*ne == '|') break;
     421             :     }
     422           0 :     equiv = SWIG_TypeNameComp(nb, ne, tb, te);
     423           0 :     if (*ne) ++ne;
     424             :   }
     425           0 :   return equiv;
     426             : }
     427             : 
     428             : /*
     429             :   Check type equivalence in a name list like <name1>|<name2>|...
     430             :   Return 0 if not equal, 1 if equal
     431             : */
     432             : SWIGRUNTIME int
     433             : SWIG_TypeEquiv(const char *nb, const char *tb) {
     434           0 :   return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
     435             : }
     436             : 
     437             : /*
     438             :   Check the typename
     439             : */
     440             : SWIGRUNTIME swig_cast_info *
     441           2 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
     442           2 :   if (ty) {
     443           2 :     swig_cast_info *iter = ty->cast;
     444           6 :     while (iter) {
     445           2 :       if (strcmp(iter->type->name, c) == 0) {
     446           0 :         if (iter == ty->cast)
     447             :           return iter;
     448             :         /* Move iter to the top of the linked list */
     449           0 :         iter->prev->next = iter->next;
     450           0 :         if (iter->next)
     451           0 :           iter->next->prev = iter->prev;
     452           0 :         iter->next = ty->cast;
     453           0 :         iter->prev = 0;
     454           0 :         if (ty->cast) ty->cast->prev = iter;
     455           0 :         ty->cast = iter;
     456           0 :         return iter;
     457             :       }
     458           2 :       iter = iter->next;
     459             :     }
     460             :   }
     461             :   return 0;
     462             : }
     463             : 
     464             : /*
     465             :   Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
     466             : */
     467             : SWIGRUNTIME swig_cast_info *
     468             : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
     469             :   if (ty) {
     470             :     swig_cast_info *iter = ty->cast;
     471             :     while (iter) {
     472             :       if (iter->type == from) {
     473             :         if (iter == ty->cast)
     474             :           return iter;
     475             :         /* Move iter to the top of the linked list */
     476             :         iter->prev->next = iter->next;
     477             :         if (iter->next)
     478             :           iter->next->prev = iter->prev;
     479             :         iter->next = ty->cast;
     480             :         iter->prev = 0;
     481             :         if (ty->cast) ty->cast->prev = iter;
     482             :         ty->cast = iter;
     483             :         return iter;
     484             :       }
     485             :       iter = iter->next;
     486             :     }
     487             :   }
     488             :   return 0;
     489             : }
     490             : 
     491             : /*
     492             :   Cast a pointer up an inheritance hierarchy
     493             : */
     494             : SWIGRUNTIMEINLINE void *
     495             : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
     496           0 :   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
     497             : }
     498             : 
     499             : /*
     500             :    Dynamic pointer casting. Down an inheritance hierarchy
     501             : */
     502             : SWIGRUNTIME swig_type_info *
     503             : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
     504             :   swig_type_info *lastty = ty;
     505             :   if (!ty || !ty->dcast) return ty;
     506             :   while (ty && (ty->dcast)) {
     507             :     ty = (*ty->dcast)(ptr);
     508             :     if (ty) lastty = ty;
     509             :   }
     510             :   return lastty;
     511             : }
     512             : 
     513             : /*
     514             :   Return the name associated with this type
     515             : */
     516             : SWIGRUNTIMEINLINE const char *
     517             : SWIG_TypeName(const swig_type_info *ty) {
     518             :   return ty->name;
     519             : }
     520             : 
     521             : /*
     522             :   Return the pretty name associated with this type,
     523             :   that is an unmangled type name in a form presentable to the user.
     524             : */
     525             : SWIGRUNTIME const char *
     526             : SWIG_TypePrettyName(const swig_type_info *type) {
     527             :   /* The "str" field contains the equivalent pretty names of the
     528             :      type, separated by vertical-bar characters.  We choose
     529             :      to print the last name, as it is often (?) the most
     530             :      specific. */
     531         923 :   if (!type) return NULL;
     532         923 :   if (type->str != NULL) {
     533             :     const char *last_name = type->str;
     534             :     const char *s;
     535       32305 :     for (s = type->str; *s; s++)
     536       15691 :       if (*s == '|') last_name = s+1;
     537             :     return last_name;
     538             :   }
     539             :   else
     540           0 :     return type->name;
     541             : }
     542             : 
     543             : /*
     544             :    Set the clientdata field for a type
     545             : */
     546             : SWIGRUNTIME void
     547       44770 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
     548       44770 :   swig_cast_info *cast = ti->cast;
     549             :   /* if (ti->clientdata == clientdata) return; */
     550       44770 :   ti->clientdata = clientdata;
     551             : 
     552       89540 :   while (cast) {
     553       44770 :     if (!cast->converter) {
     554       44770 :       swig_type_info *tc = cast->type;
     555       44770 :       if (!tc->clientdata) {
     556           0 :         SWIG_TypeClientData(tc, clientdata);
     557             :       }
     558             :     }
     559       44770 :     cast = cast->next;
     560             :   }
     561       44770 : }
     562             : SWIGRUNTIME void
     563             : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
     564       44770 :   SWIG_TypeClientData(ti, clientdata);
     565       44770 :   ti->owndata = 1;
     566             : }
     567             : 
     568             : /*
     569             :   Search for a swig_type_info structure only by mangled name
     570             :   Search is a O(log #types)
     571             : 
     572             :   We start searching at module start, and finish searching when start == end.
     573             :   Note: if start == end at the beginning of the function, we go all the way around
     574             :   the circular list.
     575             : */
     576             : SWIGRUNTIME swig_type_info *
     577          16 : SWIG_MangledTypeQueryModule(swig_module_info *start,
     578             :                             swig_module_info *end,
     579             :                             const char *name) {
     580          16 :   swig_module_info *iter = start;
     581             :   do {
     582          16 :     if (iter->size) {
     583          16 :       size_t l = 0;
     584          16 :       size_t r = iter->size - 1;
     585             :       do {
     586             :         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
     587          96 :         size_t i = (l + r) >> 1;
     588          96 :         const char *iname = iter->types[i]->name;
     589          96 :         if (iname) {
     590          96 :           int compare = strcmp(name, iname);
     591          96 :           if (compare == 0) {
     592             :             return iter->types[i];
     593          80 :           } else if (compare < 0) {
     594          80 :             if (i) {
     595          80 :               r = i - 1;
     596             :             } else {
     597             :               break;
     598             :             }
     599             :           } else if (compare > 0) {
     600           0 :             l = i + 1;
     601             :           }
     602             :         } else {
     603             :           break; /* should never happen */
     604             :         }
     605          80 :       } while (l <= r);
     606             :     }
     607           0 :     iter = iter->next;
     608           0 :   } while (iter != end);
     609             :   return 0;
     610             : }
     611             : 
     612             : /*
     613             :   Search for a swig_type_info structure for either a mangled name or a human readable name.
     614             :   It first searches the mangled names of the types, which is a O(log #types)
     615             :   If a type is not found it then searches the human readable names, which is O(#types).
     616             : 
     617             :   We start searching at module start, and finish searching when start == end.
     618             :   Note: if start == end at the beginning of the function, we go all the way around
     619             :   the circular list.
     620             : */
     621             : SWIGRUNTIME swig_type_info *
     622          16 : SWIG_TypeQueryModule(swig_module_info *start,
     623             :                      swig_module_info *end,
     624             :                      const char *name) {
     625             :   /* STEP 1: Search the name field using binary search */
     626          16 :   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
     627          16 :   if (ret) {
     628             :     return ret;
     629             :   } else {
     630             :     /* STEP 2: If the type hasn't been found, do a complete search
     631             :        of the str field (the human readable name) */
     632             :     swig_module_info *iter = start;
     633             :     do {
     634           0 :       size_t i = 0;
     635           0 :       for (; i < iter->size; ++i) {
     636           0 :         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
     637             :           return iter->types[i];
     638             :       }
     639           0 :       iter = iter->next;
     640           0 :     } while (iter != end);
     641             :   }
     642             : 
     643             :   /* neither found a match */
     644             :   return 0;
     645             : }
     646             : 
     647             : /*
     648             :    Pack binary data into a string
     649             : */
     650             : SWIGRUNTIME char *
     651             : SWIG_PackData(char *c, void *ptr, size_t sz) {
     652             :   static const char hex[17] = "0123456789abcdef";
     653           0 :   const unsigned char *u = (unsigned char *) ptr;
     654           0 :   const unsigned char *eu =  u + sz;
     655           0 :   for (; u != eu; ++u) {
     656           0 :     unsigned char uu = *u;
     657           0 :     *(c++) = hex[(uu & 0xf0) >> 4];
     658           0 :     *(c++) = hex[uu & 0xf];
     659             :   }
     660             :   return c;
     661             : }
     662             : 
     663             : /*
     664             :    Unpack binary data from a string
     665             : */
     666             : SWIGRUNTIME const char *
     667           0 : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
     668           0 :   unsigned char *u = (unsigned char *) ptr;
     669           0 :   const unsigned char *eu = u + sz;
     670           0 :   for (; u != eu; ++u) {
     671           0 :     char d = *(c++);
     672             :     unsigned char uu;
     673           0 :     if ((d >= '0') && (d <= '9'))
     674           0 :       uu = (unsigned char)((d - '0') << 4);
     675           0 :     else if ((d >= 'a') && (d <= 'f'))
     676           0 :       uu = (unsigned char)((d - ('a'-10)) << 4);
     677             :     else
     678             :       return (char *) 0;
     679           0 :     d = *(c++);
     680           0 :     if ((d >= '0') && (d <= '9'))
     681           0 :       uu |= (unsigned char)(d - '0');
     682           0 :     else if ((d >= 'a') && (d <= 'f'))
     683           0 :       uu |= (unsigned char)(d - ('a'-10));
     684             :     else
     685             :       return (char *) 0;
     686           0 :     *u = uu;
     687             :   }
     688             :   return c;
     689             : }
     690             : 
     691             : /*
     692             :    Pack 'void *' into a string buffer.
     693             : */
     694             : SWIGRUNTIME char *
     695           0 : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
     696           0 :   char *r = buff;
     697           0 :   if ((2*sizeof(void *) + 2) > bsz) return 0;
     698           0 :   *(r++) = '_';
     699           0 :   r = SWIG_PackData(r,&ptr,sizeof(void *));
     700           0 :   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
     701           0 :   strcpy(r,name);
     702           0 :   return buff;
     703             : }
     704             : 
     705             : SWIGRUNTIME const char *
     706           0 : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
     707           0 :   if (*c != '_') {
     708           0 :     if (strcmp(c,"NULL") == 0) {
     709           0 :       *ptr = (void *) 0;
     710           0 :       return name;
     711             :     } else {
     712             :       return 0;
     713             :     }
     714             :   }
     715           0 :   return SWIG_UnpackData(++c,ptr,sizeof(void *));
     716             : }
     717             : 
     718             : SWIGRUNTIME char *
     719           0 : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
     720           0 :   char *r = buff;
     721           0 :   size_t lname = (name ? strlen(name) : 0);
     722           0 :   if ((2*sz + 2 + lname) > bsz) return 0;
     723           0 :   *(r++) = '_';
     724           0 :   r = SWIG_PackData(r,ptr,sz);
     725           0 :   if (lname) {
     726           0 :     strncpy(r,name,lname+1);
     727             :   } else {
     728           0 :     *r = 0;
     729             :   }
     730             :   return buff;
     731             : }
     732             : 
     733             : SWIGRUNTIME const char *
     734             : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
     735             :   if (*c != '_') {
     736             :     if (strcmp(c,"NULL") == 0) {
     737             :       memset(ptr,0,sz);
     738             :       return name;
     739             :     } else {
     740             :       return 0;
     741             :     }
     742             :   }
     743             :   return SWIG_UnpackData(++c,ptr,sz);
     744             : }
     745             : 
     746             : #ifdef __cplusplus
     747             : }
     748             : #endif
     749             : 
     750             : /*  Errors in SWIG */
     751             : #define  SWIG_UnknownError         -1
     752             : #define  SWIG_IOError              -2
     753             : #define  SWIG_RuntimeError         -3
     754             : #define  SWIG_IndexError           -4
     755             : #define  SWIG_TypeError            -5
     756             : #define  SWIG_DivisionByZero       -6
     757             : #define  SWIG_OverflowError        -7
     758             : #define  SWIG_SyntaxError          -8
     759             : #define  SWIG_ValueError           -9
     760             : #define  SWIG_SystemError          -10
     761             : #define  SWIG_AttributeError       -11
     762             : #define  SWIG_MemoryError          -12
     763             : #define  SWIG_NullReferenceError   -13
     764             : 
     765             : 
     766             : 
     767             : /* Compatibility macros for Python 3 */
     768             : #if PY_VERSION_HEX >= 0x03000000
     769             : 
     770             : #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
     771             : #define PyInt_Check(x) PyLong_Check(x)
     772             : #define PyInt_AsLong(x) PyLong_AsLong(x)
     773             : #define PyInt_FromLong(x) PyLong_FromLong(x)
     774             : #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
     775             : #define PyString_Check(name) PyBytes_Check(name)
     776             : #define PyString_FromString(x) PyUnicode_FromString(x)
     777             : #define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
     778             : #define PyString_AsString(str) PyBytes_AsString(str)
     779             : #define PyString_Size(str) PyBytes_Size(str)    
     780             : #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
     781             : #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
     782             : #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
     783             : #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
     784             : 
     785             : #endif
     786             : 
     787             : #ifndef Py_TYPE
     788             : #  define Py_TYPE(op) ((op)->ob_type)
     789             : #endif
     790             : 
     791             : /* SWIG APIs for compatibility of both Python 2 & 3 */
     792             : 
     793             : #if PY_VERSION_HEX >= 0x03000000
     794             : #  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
     795             : #else
     796             : #  define SWIG_Python_str_FromFormat PyString_FromFormat
     797             : #endif
     798             : 
     799             : 
     800             : /* Warning: This function will allocate a new string in Python 3,
     801             :  * so please call SWIG_Python_str_DelForPy3(x) to free the space.
     802             :  */
     803             : SWIGINTERN char*
     804             : SWIG_Python_str_AsChar(PyObject *str)
     805             : {
     806             : #if PY_VERSION_HEX >= 0x03000000
     807             :   char *cstr;
     808             :   char *newstr;
     809             :   Py_ssize_t len;
     810             :   str = PyUnicode_AsUTF8String(str);
     811             :   PyBytes_AsStringAndSize(str, &cstr, &len);
     812             :   newstr = (char *) malloc(len+1);
     813             :   memcpy(newstr, cstr, len+1);
     814             :   Py_XDECREF(str);
     815             :   return newstr;
     816             : #else
     817           0 :   return PyString_AsString(str);
     818             : #endif
     819             : }
     820             : 
     821             : #if PY_VERSION_HEX >= 0x03000000
     822             : #  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
     823             : #else
     824             : #  define SWIG_Python_str_DelForPy3(x) 
     825             : #endif
     826             : 
     827             : 
     828             : SWIGINTERN PyObject*
     829             : SWIG_Python_str_FromChar(const char *c)
     830             : {
     831             : #if PY_VERSION_HEX >= 0x03000000
     832             :   return PyUnicode_FromString(c); 
     833             : #else
     834         605 :   return PyString_FromString(c);
     835             : #endif
     836             : }
     837             : 
     838             : /* Add PyOS_snprintf for old Pythons */
     839             : #if PY_VERSION_HEX < 0x02020000
     840             : # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
     841             : #  define PyOS_snprintf _snprintf
     842             : # else
     843             : #  define PyOS_snprintf snprintf
     844             : # endif
     845             : #endif
     846             : 
     847             : /* A crude PyString_FromFormat implementation for old Pythons */
     848             : #if PY_VERSION_HEX < 0x02020000
     849             : 
     850             : #ifndef SWIG_PYBUFFER_SIZE
     851             : # define SWIG_PYBUFFER_SIZE 1024
     852             : #endif
     853             : 
     854             : static PyObject *
     855             : PyString_FromFormat(const char *fmt, ...) {
     856             :   va_list ap;
     857             :   char buf[SWIG_PYBUFFER_SIZE * 2];
     858             :   int res;
     859             :   va_start(ap, fmt);
     860             :   res = vsnprintf(buf, sizeof(buf), fmt, ap);
     861             :   va_end(ap);
     862             :   return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
     863             : }
     864             : #endif
     865             : 
     866             : #ifndef PyObject_DEL
     867             : # define PyObject_DEL PyObject_Del
     868             : #endif
     869             : 
     870             : /* A crude PyExc_StopIteration exception for old Pythons */
     871             : #if PY_VERSION_HEX < 0x02020000
     872             : # ifndef PyExc_StopIteration
     873             : #  define PyExc_StopIteration PyExc_RuntimeError
     874             : # endif
     875             : # ifndef PyObject_GenericGetAttr
     876             : #  define PyObject_GenericGetAttr 0
     877             : # endif
     878             : #endif
     879             : 
     880             : /* Py_NotImplemented is defined in 2.1 and up. */
     881             : #if PY_VERSION_HEX < 0x02010000
     882             : # ifndef Py_NotImplemented
     883             : #  define Py_NotImplemented PyExc_RuntimeError
     884             : # endif
     885             : #endif
     886             : 
     887             : /* A crude PyString_AsStringAndSize implementation for old Pythons */
     888             : #if PY_VERSION_HEX < 0x02010000
     889             : # ifndef PyString_AsStringAndSize
     890             : #  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
     891             : # endif
     892             : #endif
     893             : 
     894             : /* PySequence_Size for old Pythons */
     895             : #if PY_VERSION_HEX < 0x02000000
     896             : # ifndef PySequence_Size
     897             : #  define PySequence_Size PySequence_Length
     898             : # endif
     899             : #endif
     900             : 
     901             : /* PyBool_FromLong for old Pythons */
     902             : #if PY_VERSION_HEX < 0x02030000
     903             : static
     904             : PyObject *PyBool_FromLong(long ok)
     905             : {
     906             :   PyObject *result = ok ? Py_True : Py_False;
     907             :   Py_INCREF(result);
     908             :   return result;
     909             : }
     910             : #endif
     911             : 
     912             : /* Py_ssize_t for old Pythons */
     913             : /* This code is as recommended by: */
     914             : /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
     915             : #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
     916             : typedef int Py_ssize_t;
     917             : # define PY_SSIZE_T_MAX INT_MAX
     918             : # define PY_SSIZE_T_MIN INT_MIN
     919             : typedef inquiry lenfunc;
     920             : typedef intargfunc ssizeargfunc;
     921             : typedef intintargfunc ssizessizeargfunc;
     922             : typedef intobjargproc ssizeobjargproc;
     923             : typedef intintobjargproc ssizessizeobjargproc;
     924             : typedef getreadbufferproc readbufferproc;
     925             : typedef getwritebufferproc writebufferproc;
     926             : typedef getsegcountproc segcountproc;
     927             : typedef getcharbufferproc charbufferproc;
     928             : static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
     929             : {
     930             :   long result = 0;
     931             :   PyObject *i = PyNumber_Int(x);
     932             :   if (i) {
     933             :     result = PyInt_AsLong(i);
     934             :     Py_DECREF(i);
     935             :   }
     936             :   return result;
     937             : }
     938             : #endif
     939             : 
     940             : #if PY_VERSION_HEX < 0x02050000
     941             : #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
     942             : #endif
     943             : 
     944             : #if PY_VERSION_HEX < 0x02040000
     945             : #define Py_VISIT(op)                            \
     946             :   do {                                          \
     947             :     if (op) {                                   \
     948             :       int vret = visit((op), arg);              \
     949             :       if (vret)                                 \
     950             :         return vret;                            \
     951             :     }                                           \
     952             :   } while (0)
     953             : #endif
     954             : 
     955             : #if PY_VERSION_HEX < 0x02030000
     956             : typedef struct {
     957             :   PyTypeObject type;
     958             :   PyNumberMethods as_number;
     959             :   PyMappingMethods as_mapping;
     960             :   PySequenceMethods as_sequence;
     961             :   PyBufferProcs as_buffer;
     962             :   PyObject *name, *slots;
     963             : } PyHeapTypeObject;
     964             : #endif
     965             : 
     966             : #if PY_VERSION_HEX < 0x02030000
     967             : typedef destructor freefunc;
     968             : #endif
     969             : 
     970             : #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
     971             :      (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
     972             :      (PY_MAJOR_VERSION > 3))
     973             : # define SWIGPY_USE_CAPSULE
     974             : # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
     975             : #endif
     976             : 
     977             : #if PY_VERSION_HEX < 0x03020000
     978             : #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
     979             : #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
     980             : #define Py_hash_t long
     981             : #endif
     982             : 
     983             : /* -----------------------------------------------------------------------------
     984             :  * error manipulation
     985             :  * ----------------------------------------------------------------------------- */
     986             : 
     987             : SWIGRUNTIME PyObject*
     988           0 : SWIG_Python_ErrorType(int code) {
     989           0 :   PyObject* type = 0;
     990           0 :   switch(code) {
     991           0 :   case SWIG_MemoryError:
     992           0 :     type = PyExc_MemoryError;
     993           0 :     break;
     994           0 :   case SWIG_IOError:
     995           0 :     type = PyExc_IOError;
     996           0 :     break;
     997           0 :   case SWIG_RuntimeError:
     998           0 :     type = PyExc_RuntimeError;
     999           0 :     break;
    1000           0 :   case SWIG_IndexError:
    1001           0 :     type = PyExc_IndexError;
    1002           0 :     break;
    1003           0 :   case SWIG_TypeError:
    1004           0 :     type = PyExc_TypeError;
    1005           0 :     break;
    1006           0 :   case SWIG_DivisionByZero:
    1007           0 :     type = PyExc_ZeroDivisionError;
    1008           0 :     break;
    1009           0 :   case SWIG_OverflowError:
    1010           0 :     type = PyExc_OverflowError;
    1011           0 :     break;
    1012           0 :   case SWIG_SyntaxError:
    1013           0 :     type = PyExc_SyntaxError;
    1014           0 :     break;
    1015           0 :   case SWIG_ValueError:
    1016           0 :     type = PyExc_ValueError;
    1017           0 :     break;
    1018           0 :   case SWIG_SystemError:
    1019           0 :     type = PyExc_SystemError;
    1020           0 :     break;
    1021           0 :   case SWIG_AttributeError:
    1022           0 :     type = PyExc_AttributeError;
    1023           0 :     break;
    1024           0 :   default:
    1025           0 :     type = PyExc_RuntimeError;
    1026             :   }
    1027           0 :   return type;
    1028             : }
    1029             : 
    1030             : 
    1031             : SWIGRUNTIME void
    1032             : SWIG_Python_AddErrorMsg(const char* mesg)
    1033             : {
    1034             :   PyObject *type = 0;
    1035             :   PyObject *value = 0;
    1036             :   PyObject *traceback = 0;
    1037             : 
    1038             :   if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
    1039             :   if (value) {
    1040             :     char *tmp;
    1041             :     PyObject *old_str = PyObject_Str(value);
    1042             :     PyErr_Clear();
    1043             :     Py_XINCREF(type);
    1044             : 
    1045             :     PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    1046             :     SWIG_Python_str_DelForPy3(tmp);
    1047             :     Py_DECREF(old_str);
    1048             :     Py_DECREF(value);
    1049             :   } else {
    1050             :     PyErr_SetString(PyExc_RuntimeError, mesg);
    1051             :   }
    1052             : }
    1053             : 
    1054             : #if defined(SWIG_PYTHON_NO_THREADS)
    1055             : #  if defined(SWIG_PYTHON_THREADS)
    1056             : #    undef SWIG_PYTHON_THREADS
    1057             : #  endif
    1058             : #endif
    1059             : #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
    1060             : #  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
    1061             : #    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
    1062             : #      define SWIG_PYTHON_USE_GIL
    1063             : #    endif
    1064             : #  endif
    1065             : #  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
    1066             : #    ifndef SWIG_PYTHON_INITIALIZE_THREADS
    1067             : #     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
    1068             : #    endif
    1069             : #    ifdef __cplusplus /* C++ code */
    1070             :        class SWIG_Python_Thread_Block {
    1071             :          bool status;
    1072             :          PyGILState_STATE state;
    1073             :        public:
    1074           0 :          void end() { if (status) { PyGILState_Release(state); status = false;} }
    1075           0 :          SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
    1076           0 :          ~SWIG_Python_Thread_Block() { end(); }
    1077             :        };
    1078             :        class SWIG_Python_Thread_Allow {
    1079             :          bool status;
    1080             :          PyThreadState *save;
    1081             :        public:
    1082      324848 :          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
    1083      324848 :          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
    1084      324848 :          ~SWIG_Python_Thread_Allow() { end(); }
    1085             :        };
    1086             : #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
    1087             : #      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
    1088             : #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
    1089             : #      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
    1090             : #    else /* C code */
    1091             : #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
    1092             : #      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
    1093             : #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
    1094             : #      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
    1095             : #    endif
    1096             : #  else /* Old thread way, not implemented, user must provide it */
    1097             : #    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
    1098             : #      define SWIG_PYTHON_INITIALIZE_THREADS
    1099             : #    endif
    1100             : #    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
    1101             : #      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
    1102             : #    endif
    1103             : #    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
    1104             : #      define SWIG_PYTHON_THREAD_END_BLOCK
    1105             : #    endif
    1106             : #    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
    1107             : #      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
    1108             : #    endif
    1109             : #    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
    1110             : #      define SWIG_PYTHON_THREAD_END_ALLOW
    1111             : #    endif
    1112             : #  endif
    1113             : #else /* No thread support */
    1114             : #  define SWIG_PYTHON_INITIALIZE_THREADS
    1115             : #  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
    1116             : #  define SWIG_PYTHON_THREAD_END_BLOCK
    1117             : #  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
    1118             : #  define SWIG_PYTHON_THREAD_END_ALLOW
    1119             : #endif
    1120             : 
    1121             : /* -----------------------------------------------------------------------------
    1122             :  * Python API portion that goes into the runtime
    1123             :  * ----------------------------------------------------------------------------- */
    1124             : 
    1125             : #ifdef __cplusplus
    1126             : extern "C" {
    1127             : #endif
    1128             : 
    1129             : /* -----------------------------------------------------------------------------
    1130             :  * Constant declarations
    1131             :  * ----------------------------------------------------------------------------- */
    1132             : 
    1133             : /* Constant Types */
    1134             : #define SWIG_PY_POINTER 4
    1135             : #define SWIG_PY_BINARY  5
    1136             : 
    1137             : /* Constant information structure */
    1138             : typedef struct swig_const_info {
    1139             :   int type;
    1140             :   char *name;
    1141             :   long lvalue;
    1142             :   double dvalue;
    1143             :   void   *pvalue;
    1144             :   swig_type_info **ptype;
    1145             : } swig_const_info;
    1146             : 
    1147             : 
    1148             : /* -----------------------------------------------------------------------------
    1149             :  * Wrapper of PyInstanceMethod_New() used in Python 3
    1150             :  * It is exported to the generated module, used for -fastproxy
    1151             :  * ----------------------------------------------------------------------------- */
    1152             : #if PY_VERSION_HEX >= 0x03000000
    1153             : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
    1154             : {
    1155             :   return PyInstanceMethod_New(func);
    1156             : }
    1157             : #else
    1158           0 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
    1159             : {
    1160           0 :   return NULL;
    1161             : }
    1162             : #endif
    1163             : 
    1164             : #ifdef __cplusplus
    1165             : }
    1166             : #endif
    1167             : 
    1168             : 
    1169             : /* -----------------------------------------------------------------------------
    1170             :  * pyrun.swg
    1171             :  *
    1172             :  * This file contains the runtime support for Python modules
    1173             :  * and includes code for managing global variables and pointer
    1174             :  * type checking.
    1175             :  *
    1176             :  * ----------------------------------------------------------------------------- */
    1177             : 
    1178             : /* Common SWIG API */
    1179             : 
    1180             : /* for raw pointers */
    1181             : #define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
    1182             : #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
    1183             : #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
    1184             : 
    1185             : #ifdef SWIGPYTHON_BUILTIN
    1186             : #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
    1187             : #else
    1188             : #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
    1189             : #endif
    1190             : 
    1191             : #define SWIG_InternalNewPointerObj(ptr, type, flags)    SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
    1192             : 
    1193             : #define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
    1194             : #define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
    1195             : #define swig_owntype                                    int
    1196             : 
    1197             : /* for raw packed data */
    1198             : #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
    1199             : #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
    1200             : 
    1201             : /* for class or struct pointers */
    1202             : #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
    1203             : #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
    1204             : 
    1205             : /* for C or C++ function pointers */
    1206             : #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
    1207             : #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
    1208             : 
    1209             : /* for C++ member pointers, ie, member methods */
    1210             : #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
    1211             : #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)
    1212             : 
    1213             : 
    1214             : /* Runtime API */
    1215             : 
    1216             : #define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
    1217             : #define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
    1218             : #define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)
    1219             : 
    1220             : #define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
    1221             : #define SWIG_SetErrorMsg                                SWIG_Python_SetErrorMsg                            
    1222             : #define SWIG_ErrorType(code)                            SWIG_Python_ErrorType(code)                        
    1223             : #define SWIG_Error(code, msg)                           SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
    1224             : #define SWIG_fail                                       goto fail                                          
    1225             : 
    1226             : 
    1227             : /* Runtime API implementation */
    1228             : 
    1229             : /* Error manipulation */
    1230             : 
    1231             : SWIGINTERN void 
    1232             : SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
    1233             :   SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
    1234             :   PyErr_SetObject(errtype, obj);
    1235             :   Py_DECREF(obj);
    1236             :   SWIG_PYTHON_THREAD_END_BLOCK;
    1237             : }
    1238             : 
    1239             : SWIGINTERN void 
    1240           0 : SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
    1241           0 :   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    1242           0 :   PyErr_SetString(errtype, msg);
    1243           0 :   SWIG_PYTHON_THREAD_END_BLOCK;
    1244           0 : }
    1245             : 
    1246             : #define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
    1247             : 
    1248             : /* Set a constant value */
    1249             : 
    1250             : #if defined(SWIGPYTHON_BUILTIN)
    1251             : 
    1252             : SWIGINTERN void
    1253             : SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
    1254             :   PyObject *s = PyString_InternFromString(key);
    1255             :   PyList_Append(seq, s);
    1256             :   Py_DECREF(s);
    1257             : }
    1258             : 
    1259             : SWIGINTERN void
    1260             : SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
    1261             : #if PY_VERSION_HEX < 0x02030000
    1262             :   PyDict_SetItemString(d, (char *)name, obj);
    1263             : #else
    1264             :   PyDict_SetItemString(d, name, obj);
    1265             : #endif
    1266             :   Py_DECREF(obj);
    1267             :   if (public_interface)
    1268             :     SwigPyBuiltin_AddPublicSymbol(public_interface, name);
    1269             : }
    1270             : 
    1271             : #else
    1272             : 
    1273             : SWIGINTERN void
    1274      424424 : SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
    1275             : #if PY_VERSION_HEX < 0x02030000
    1276             :   PyDict_SetItemString(d, (char *)name, obj);
    1277             : #else
    1278      424424 :   PyDict_SetItemString(d, name, obj);
    1279             : #endif
    1280      424424 :   Py_DECREF(obj);                            
    1281      424424 : }
    1282             : 
    1283             : #endif
    1284             : 
    1285             : /* Append a value to the result obj */
    1286             : 
    1287             : SWIGINTERN PyObject*
    1288             : SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
    1289             : #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
    1290             :   if (!result) {
    1291             :     result = obj;
    1292             :   } else if (result == Py_None) {
    1293             :     Py_DECREF(result);
    1294             :     result = obj;
    1295             :   } else {
    1296             :     if (!PyList_Check(result)) {
    1297             :       PyObject *o2 = result;
    1298             :       result = PyList_New(1);
    1299             :       PyList_SetItem(result, 0, o2);
    1300             :     }
    1301             :     PyList_Append(result,obj);
    1302             :     Py_DECREF(obj);
    1303             :   }
    1304             :   return result;
    1305             : #else
    1306             :   PyObject*   o2;
    1307             :   PyObject*   o3;
    1308             :   if (!result) {
    1309             :     result = obj;
    1310             :   } else if (result == Py_None) {
    1311             :     Py_DECREF(result);
    1312             :     result = obj;
    1313             :   } else {
    1314             :     if (!PyTuple_Check(result)) {
    1315             :       o2 = result;
    1316             :       result = PyTuple_New(1);
    1317             :       PyTuple_SET_ITEM(result, 0, o2);
    1318             :     }
    1319             :     o3 = PyTuple_New(1);
    1320             :     PyTuple_SET_ITEM(o3, 0, obj);
    1321             :     o2 = result;
    1322             :     result = PySequence_Concat(o2, o3);
    1323             :     Py_DECREF(o2);
    1324             :     Py_DECREF(o3);
    1325             :   }
    1326             :   return result;
    1327             : #endif
    1328             : }
    1329             : 
    1330             : /* Unpack the argument tuple */
    1331             : 
    1332             : SWIGINTERN Py_ssize_t
    1333             : SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
    1334             : {
    1335             :   if (!args) {
    1336             :     if (!min && !max) {
    1337             :       return 1;
    1338             :     } else {
    1339             :       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
    1340             :                    name, (min == max ? "" : "at least "), (int)min);
    1341             :       return 0;
    1342             :     }
    1343             :   }  
    1344             :   if (!PyTuple_Check(args)) {
    1345             :     if (min <= 1 && max >= 1) {
    1346             :       Py_ssize_t i;
    1347             :       objs[0] = args;
    1348             :       for (i = 1; i < max; ++i) {
    1349             :         objs[i] = 0;
    1350             :       }
    1351             :       return 2;
    1352             :     }
    1353             :     PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    1354             :     return 0;
    1355             :   } else {
    1356             :     Py_ssize_t l = PyTuple_GET_SIZE(args);
    1357             :     if (l < min) {
    1358             :       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
    1359             :                    name, (min == max ? "" : "at least "), (int)min, (int)l);
    1360             :       return 0;
    1361             :     } else if (l > max) {
    1362             :       PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
    1363             :                    name, (min == max ? "" : "at most "), (int)max, (int)l);
    1364             :       return 0;
    1365             :     } else {
    1366             :       Py_ssize_t i;
    1367             :       for (i = 0; i < l; ++i) {
    1368             :         objs[i] = PyTuple_GET_ITEM(args, i);
    1369             :       }
    1370             :       for (; l < max; ++l) {
    1371             :         objs[l] = 0;
    1372             :       }
    1373             :       return i + 1;
    1374             :     }    
    1375             :   }
    1376             : }
    1377             : 
    1378             : /* A functor is a function object with one single object argument */
    1379             : #if PY_VERSION_HEX >= 0x02020000
    1380             : #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunctionObjArgs(functor, obj, NULL);
    1381             : #else
    1382             : #define SWIG_Python_CallFunctor(functor, obj)           PyObject_CallFunction(functor, "O", obj);
    1383             : #endif
    1384             : 
    1385             : /*
    1386             :   Helper for static pointer initialization for both C and C++ code, for example
    1387             :   static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
    1388             : */
    1389             : #ifdef __cplusplus
    1390             : #define SWIG_STATIC_POINTER(var)  var
    1391             : #else
    1392             : #define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
    1393             : #endif
    1394             : 
    1395             : /* -----------------------------------------------------------------------------
    1396             :  * Pointer declarations
    1397             :  * ----------------------------------------------------------------------------- */
    1398             : 
    1399             : /* Flags for new pointer objects */
    1400             : #define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
    1401             : #define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
    1402             : 
    1403             : #define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)
    1404             : 
    1405             : #define SWIG_BUILTIN_TP_INIT        (SWIG_POINTER_OWN << 2)
    1406             : #define SWIG_BUILTIN_INIT           (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
    1407             : 
    1408             : #ifdef __cplusplus
    1409             : extern "C" {
    1410             : #endif
    1411             : 
    1412             : /*  How to access Py_None */
    1413             : #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
    1414             : #  ifndef SWIG_PYTHON_NO_BUILD_NONE
    1415             : #    ifndef SWIG_PYTHON_BUILD_NONE
    1416             : #      define SWIG_PYTHON_BUILD_NONE
    1417             : #    endif
    1418             : #  endif
    1419             : #endif
    1420             : 
    1421             : #ifdef SWIG_PYTHON_BUILD_NONE
    1422             : #  ifdef Py_None
    1423             : #   undef Py_None
    1424             : #   define Py_None SWIG_Py_None()
    1425             : #  endif
    1426             : SWIGRUNTIMEINLINE PyObject * 
    1427             : _SWIG_Py_None(void)
    1428             : {
    1429             :   PyObject *none = Py_BuildValue((char*)"");
    1430             :   Py_DECREF(none);
    1431             :   return none;
    1432             : }
    1433             : SWIGRUNTIME PyObject * 
    1434             : SWIG_Py_None(void)
    1435             : {
    1436             :   static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
    1437             :   return none;
    1438             : }
    1439             : #endif
    1440             : 
    1441             : /* The python void return value */
    1442             : 
    1443             : SWIGRUNTIMEINLINE PyObject * 
    1444             : SWIG_Py_Void(void)
    1445             : {
    1446      140140 :   PyObject *none = Py_None;
    1447      140140 :   Py_INCREF(none);
    1448             :   return none;
    1449             : }
    1450             : 
    1451             : /* SwigPyClientData */
    1452             : 
    1453             : typedef struct {
    1454             :   PyObject *klass;
    1455             :   PyObject *newraw;
    1456             :   PyObject *newargs;
    1457             :   PyObject *destroy;
    1458             :   int delargs;
    1459             :   int implicitconv;
    1460             :   PyTypeObject *pytype;
    1461             : } SwigPyClientData;
    1462             : 
    1463             : SWIGRUNTIMEINLINE int 
    1464             : SWIG_Python_CheckImplicit(swig_type_info *ty)
    1465             : {
    1466             :   SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
    1467             :   return data ? data->implicitconv : 0;
    1468             : }
    1469             : 
    1470             : SWIGRUNTIMEINLINE PyObject *
    1471             : SWIG_Python_ExceptionType(swig_type_info *desc) {
    1472             :   SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
    1473             :   PyObject *klass = data ? data->klass : 0;
    1474             :   return (klass ? klass : PyExc_RuntimeError);
    1475             : }
    1476             : 
    1477             : 
    1478             : SWIGRUNTIME SwigPyClientData * 
    1479       44770 : SwigPyClientData_New(PyObject* obj)
    1480             : {
    1481       44770 :   if (!obj) {
    1482             :     return 0;
    1483             :   } else {
    1484       44770 :     SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    1485             :     /* the klass element */
    1486       44770 :     data->klass = obj;
    1487       44770 :     Py_INCREF(data->klass);
    1488             :     /* the newraw method and newargs arguments used to create a new raw instance */
    1489       44770 :     if (PyClass_Check(obj)) {
    1490           0 :       data->newraw = 0;
    1491           0 :       data->newargs = obj;
    1492           0 :       Py_INCREF(obj);
    1493             :     } else {
    1494             : #if (PY_VERSION_HEX < 0x02020000)
    1495             :       data->newraw = 0;
    1496             : #else
    1497       44770 :       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
    1498             : #endif
    1499       44770 :       if (data->newraw) {
    1500       44770 :         Py_INCREF(data->newraw);
    1501       44770 :         data->newargs = PyTuple_New(1);
    1502       44770 :         PyTuple_SetItem(data->newargs, 0, obj);
    1503             :       } else {
    1504           0 :         data->newargs = obj;
    1505             :       }
    1506       44770 :       Py_INCREF(data->newargs);
    1507             :     }
    1508             :     /* the destroy method, aka as the C++ delete method */
    1509       44770 :     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
    1510       44770 :     if (PyErr_Occurred()) {
    1511           0 :       PyErr_Clear();
    1512           0 :       data->destroy = 0;
    1513             :     }
    1514       44770 :     if (data->destroy) {
    1515             :       int flags;
    1516       44770 :       Py_INCREF(data->destroy);
    1517       44770 :       flags = PyCFunction_GET_FLAGS(data->destroy);
    1518             : #ifdef METH_O
    1519       44770 :       data->delargs = !(flags & (METH_O));
    1520             : #else
    1521             :       data->delargs = 0;
    1522             : #endif
    1523             :     } else {
    1524           0 :       data->delargs = 0;
    1525             :     }
    1526       44770 :     data->implicitconv = 0;
    1527       44770 :     data->pytype = 0;
    1528       44770 :     return data;
    1529             :   }
    1530             : }
    1531             : 
    1532             : SWIGRUNTIME void 
    1533       44770 : SwigPyClientData_Del(SwigPyClientData *data) {
    1534       44770 :   Py_XDECREF(data->newraw);
    1535       44770 :   Py_XDECREF(data->newargs);
    1536       44770 :   Py_XDECREF(data->destroy);
    1537       44770 : }
    1538             : 
    1539             : /* =============== SwigPyObject =====================*/
    1540             : 
    1541             : typedef struct {
    1542             :   PyObject_HEAD
    1543             :   void *ptr;
    1544             :   swig_type_info *ty;
    1545             :   int own;
    1546             :   PyObject *next;
    1547             : #ifdef SWIGPYTHON_BUILTIN
    1548             :   PyObject *dict;
    1549             : #endif
    1550             : } SwigPyObject;
    1551             : 
    1552             : 
    1553             : #ifdef SWIGPYTHON_BUILTIN
    1554             : 
    1555             : SWIGRUNTIME PyObject *
    1556             : SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
    1557             : {
    1558             :   SwigPyObject *sobj = (SwigPyObject *)v;
    1559             : 
    1560             :   if (!sobj->dict)
    1561             :     sobj->dict = PyDict_New();
    1562             : 
    1563             :   Py_INCREF(sobj->dict);
    1564             :   return sobj->dict;
    1565             : }
    1566             : 
    1567             : #endif
    1568             : 
    1569             : SWIGRUNTIME PyObject *
    1570           0 : SwigPyObject_long(SwigPyObject *v)
    1571             : {
    1572           0 :   return PyLong_FromVoidPtr(v->ptr);
    1573             : }
    1574             : 
    1575             : SWIGRUNTIME PyObject *
    1576           0 : SwigPyObject_format(const char* fmt, SwigPyObject *v)
    1577             : {
    1578           0 :   PyObject *res = NULL;
    1579           0 :   PyObject *args = PyTuple_New(1);
    1580           0 :   if (args) {
    1581           0 :     if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
    1582           0 :       PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
    1583           0 :       if (ofmt) {
    1584             : #if PY_VERSION_HEX >= 0x03000000
    1585             :         res = PyUnicode_Format(ofmt,args);
    1586             : #else
    1587           0 :         res = PyString_Format(ofmt,args);
    1588             : #endif
    1589           0 :         Py_DECREF(ofmt);
    1590             :       }
    1591           0 :       Py_DECREF(args);
    1592             :     }
    1593             :   }
    1594           0 :   return res;
    1595             : }
    1596             : 
    1597             : SWIGRUNTIME PyObject *
    1598           0 : SwigPyObject_oct(SwigPyObject *v)
    1599             : {
    1600           0 :   return SwigPyObject_format("%o",v);
    1601             : }
    1602             : 
    1603             : SWIGRUNTIME PyObject *
    1604           0 : SwigPyObject_hex(SwigPyObject *v)
    1605             : {
    1606           0 :   return SwigPyObject_format("%x",v);
    1607             : }
    1608             : 
    1609             : SWIGRUNTIME PyObject *
    1610             : #ifdef METH_NOARGS
    1611         923 : SwigPyObject_repr(SwigPyObject *v)
    1612             : #else
    1613             : SwigPyObject_repr(SwigPyObject *v, PyObject *args)
    1614             : #endif
    1615             : {
    1616        1846 :   const char *name = SWIG_TypePrettyName(v->ty);
    1617         923 :   PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
    1618         923 :   if (v->next) {
    1619             : # ifdef METH_NOARGS
    1620           0 :     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
    1621             : # else
    1622             :     PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
    1623             : # endif
    1624             : # if PY_VERSION_HEX >= 0x03000000
    1625             :     PyObject *joined = PyUnicode_Concat(repr, nrep);
    1626             :     Py_DecRef(repr);
    1627             :     Py_DecRef(nrep);
    1628             :     repr = joined;
    1629             : # else
    1630           0 :     PyString_ConcatAndDel(&repr,nrep);
    1631             : # endif
    1632             :   }
    1633         923 :   return repr;  
    1634             : }
    1635             : 
    1636             : SWIGRUNTIME int
    1637           0 : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
    1638             : {
    1639           0 :   void *i = v->ptr;
    1640           0 :   void *j = w->ptr;
    1641           0 :   return (i < j) ? -1 : ((i > j) ? 1 : 0);
    1642             : }
    1643             : 
    1644             : /* Added for Python 3.x, would it also be useful for Python 2.x? */
    1645             : SWIGRUNTIME PyObject*
    1646           0 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
    1647             : {
    1648             :   PyObject* res;
    1649           0 :   if( op != Py_EQ && op != Py_NE ) {
    1650           0 :     Py_INCREF(Py_NotImplemented);
    1651           0 :     return Py_NotImplemented;
    1652             :   }
    1653           0 :   res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
    1654           0 :   return res;  
    1655             : }
    1656             : 
    1657             : 
    1658             : SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
    1659             : 
    1660             : #ifdef SWIGPYTHON_BUILTIN
    1661             : static swig_type_info *SwigPyObject_stype = 0;
    1662             : SWIGRUNTIME PyTypeObject*
    1663             : SwigPyObject_type(void) {
    1664             :     SwigPyClientData *cd;
    1665             :     assert(SwigPyObject_stype);
    1666             :     cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    1667             :     assert(cd);
    1668             :     assert(cd->pytype);
    1669             :     return cd->pytype;
    1670             : }
    1671             : #else
    1672             : SWIGRUNTIME PyTypeObject*
    1673      956438 : SwigPyObject_type(void) {
    1674      956438 :   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
    1675      956438 :   return type;
    1676             : }
    1677             : #endif
    1678             : 
    1679             : SWIGRUNTIMEINLINE int
    1680      582746 : SwigPyObject_Check(PyObject *op) {
    1681             : #ifdef SWIGPYTHON_BUILTIN
    1682             :   PyTypeObject *target_tp = SwigPyObject_type();
    1683             :   if (PyType_IsSubtype(op->ob_type, target_tp))
    1684             :     return 1;
    1685             :   return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
    1686             : #else
    1687      582746 :   return (Py_TYPE(op) == SwigPyObject_type())
    1688      582746 :     || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
    1689             : #endif
    1690             : }
    1691             : 
    1692             : SWIGRUNTIME PyObject *
    1693             : SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
    1694             : 
    1695             : SWIGRUNTIME void
    1696      183346 : SwigPyObject_dealloc(PyObject *v)
    1697             : {
    1698      183346 :   SwigPyObject *sobj = (SwigPyObject *) v;
    1699      183346 :   PyObject *next = sobj->next;
    1700      183346 :   if (sobj->own == SWIG_POINTER_OWN) {
    1701       91639 :     swig_type_info *ty = sobj->ty;
    1702       91639 :     SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    1703       91639 :     PyObject *destroy = data ? data->destroy : 0;
    1704       91639 :     if (destroy) {
    1705             :       /* destroy is always a VARARGS method */
    1706             :       PyObject *res;
    1707             : 
    1708             :       /* PyObject_CallFunction() has the potential to silently drop
    1709             :          the active active exception.  In cases of unnamed temporary
    1710             :          variable or where we just finished iterating over a generator
    1711             :          StopIteration will be active right now, and this needs to
    1712             :          remain true upon return from SwigPyObject_dealloc.  So save
    1713             :          and restore. */
    1714             :       
    1715       91639 :       PyObject *val = NULL, *type = NULL, *tb = NULL;
    1716       91639 :       PyErr_Fetch(&val, &type, &tb);
    1717             : 
    1718       91639 :       if (data->delargs) {
    1719             :         /* we need to create a temporary object to carry the destroy operation */
    1720       91639 :         PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
    1721       91639 :         res = SWIG_Python_CallFunctor(destroy, tmp);
    1722       91639 :         Py_DECREF(tmp);
    1723             :       } else {
    1724           0 :         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
    1725           0 :         PyObject *mself = PyCFunction_GET_SELF(destroy);
    1726           0 :         res = ((*meth)(mself, v));
    1727             :       }
    1728       91639 :       if (!res)
    1729           0 :         PyErr_WriteUnraisable(destroy);
    1730             : 
    1731       91639 :       PyErr_Restore(val, type, tb);
    1732             : 
    1733       91639 :       Py_XDECREF(res);
    1734             :     } 
    1735             : #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    1736             :     else {
    1737           0 :       const char *name = SWIG_TypePrettyName(ty);
    1738           0 :       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    1739             :     }
    1740             : #endif
    1741             :   } 
    1742      183346 :   Py_XDECREF(next);
    1743      183346 :   PyObject_DEL(v);
    1744      183346 : }
    1745             : 
    1746             : SWIGRUNTIME PyObject* 
    1747           0 : SwigPyObject_append(PyObject* v, PyObject* next)
    1748             : {
    1749           0 :   SwigPyObject *sobj = (SwigPyObject *) v;
    1750             : #ifndef METH_O
    1751             :   PyObject *tmp = 0;
    1752             :   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
    1753             :   next = tmp;
    1754             : #endif
    1755           0 :   if (!SwigPyObject_Check(next)) {
    1756           0 :     PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    1757           0 :     return NULL;
    1758             :   }
    1759           0 :   sobj->next = next;
    1760           0 :   Py_INCREF(next);
    1761           0 :   return SWIG_Py_Void();
    1762             : }
    1763             : 
    1764             : SWIGRUNTIME PyObject* 
    1765             : #ifdef METH_NOARGS
    1766           0 : SwigPyObject_next(PyObject* v)
    1767             : #else
    1768             : SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1769             : #endif
    1770             : {
    1771           0 :   SwigPyObject *sobj = (SwigPyObject *) v;
    1772           0 :   if (sobj->next) {    
    1773           0 :     Py_INCREF(sobj->next);
    1774           0 :     return sobj->next;
    1775             :   } else {
    1776           0 :     return SWIG_Py_Void();
    1777             :   }
    1778             : }
    1779             : 
    1780             : SWIGINTERN PyObject*
    1781             : #ifdef METH_NOARGS
    1782           0 : SwigPyObject_disown(PyObject *v)
    1783             : #else
    1784             : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1785             : #endif
    1786             : {
    1787           0 :   SwigPyObject *sobj = (SwigPyObject *)v;
    1788           0 :   sobj->own = 0;
    1789           0 :   return SWIG_Py_Void();
    1790             : }
    1791             : 
    1792             : SWIGINTERN PyObject*
    1793             : #ifdef METH_NOARGS
    1794           0 : SwigPyObject_acquire(PyObject *v)
    1795             : #else
    1796             : SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1797             : #endif
    1798             : {
    1799           0 :   SwigPyObject *sobj = (SwigPyObject *)v;
    1800           0 :   sobj->own = SWIG_POINTER_OWN;
    1801           0 :   return SWIG_Py_Void();
    1802             : }
    1803             : 
    1804             : SWIGINTERN PyObject*
    1805           0 : SwigPyObject_own(PyObject *v, PyObject *args)
    1806             : {
    1807           0 :   PyObject *val = 0;
    1808             : #if (PY_VERSION_HEX < 0x02020000)
    1809             :   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
    1810             : #elif (PY_VERSION_HEX < 0x02050000)
    1811             :   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
    1812             : #else
    1813           0 :   if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
    1814             : #endif
    1815             :     {
    1816             :       return NULL;
    1817             :     } 
    1818             :   else
    1819             :     {
    1820           0 :       SwigPyObject *sobj = (SwigPyObject *)v;
    1821           0 :       PyObject *obj = PyBool_FromLong(sobj->own);
    1822           0 :       if (val) {
    1823             : #ifdef METH_NOARGS
    1824           0 :         if (PyObject_IsTrue(val)) {
    1825             :           SwigPyObject_acquire(v);
    1826             :         } else {
    1827             :           SwigPyObject_disown(v);
    1828             :         }
    1829             : #else
    1830             :         if (PyObject_IsTrue(val)) {
    1831             :           SwigPyObject_acquire(v,args);
    1832             :         } else {
    1833             :           SwigPyObject_disown(v,args);
    1834             :         }
    1835             : #endif
    1836             :       } 
    1837             :       return obj;
    1838             :     }
    1839             : }
    1840             : 
    1841             : #ifdef METH_O
    1842             : static PyMethodDef
    1843             : swigobject_methods[] = {
    1844             :   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)"releases ownership of the pointer"},
    1845             :   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)"acquires ownership of the pointer"},
    1846             :   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
    1847             :   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
    1848             :   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
    1849             :   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)"returns object representation"},
    1850             :   {0, 0, 0, 0}  
    1851             : };
    1852             : #else
    1853             : static PyMethodDef
    1854             : swigobject_methods[] = {
    1855             :   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
    1856             :   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"acquires ownership of the pointer"},
    1857             :   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
    1858             :   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
    1859             :   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
    1860             :   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)"returns object representation"},
    1861             :   {0, 0, 0, 0}  
    1862             : };
    1863             : #endif
    1864             : 
    1865             : #if PY_VERSION_HEX < 0x02020000
    1866             : SWIGINTERN PyObject *
    1867             : SwigPyObject_getattr(SwigPyObject *sobj,char *name)
    1868             : {
    1869             :   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
    1870             : }
    1871             : #endif
    1872             : 
    1873             : SWIGRUNTIME PyTypeObject*
    1874         605 : SwigPyObject_TypeOnce(void) {
    1875             :   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
    1876             : 
    1877             :   static PyNumberMethods SwigPyObject_as_number = {
    1878             :     (binaryfunc)0, /*nb_add*/
    1879             :     (binaryfunc)0, /*nb_subtract*/
    1880             :     (binaryfunc)0, /*nb_multiply*/
    1881             :     /* nb_divide removed in Python 3 */
    1882             : #if PY_VERSION_HEX < 0x03000000
    1883             :     (binaryfunc)0, /*nb_divide*/
    1884             : #endif
    1885             :     (binaryfunc)0, /*nb_remainder*/
    1886             :     (binaryfunc)0, /*nb_divmod*/
    1887             :     (ternaryfunc)0,/*nb_power*/
    1888             :     (unaryfunc)0,  /*nb_negative*/
    1889             :     (unaryfunc)0,  /*nb_positive*/
    1890             :     (unaryfunc)0,  /*nb_absolute*/
    1891             :     (inquiry)0,    /*nb_nonzero*/
    1892             :     0,             /*nb_invert*/
    1893             :     0,             /*nb_lshift*/
    1894             :     0,             /*nb_rshift*/
    1895             :     0,             /*nb_and*/
    1896             :     0,             /*nb_xor*/
    1897             :     0,             /*nb_or*/
    1898             : #if PY_VERSION_HEX < 0x03000000
    1899             :     0,   /*nb_coerce*/
    1900             : #endif
    1901             :     (unaryfunc)SwigPyObject_long, /*nb_int*/
    1902             : #if PY_VERSION_HEX < 0x03000000
    1903             :     (unaryfunc)SwigPyObject_long, /*nb_long*/
    1904             : #else
    1905             :     0, /*nb_reserved*/
    1906             : #endif
    1907             :     (unaryfunc)0,                 /*nb_float*/
    1908             : #if PY_VERSION_HEX < 0x03000000
    1909             :     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    1910             :     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
    1911             : #endif
    1912             : #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    1913             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
    1914             : #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    1915             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
    1916             : #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
    1917             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
    1918             : #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
    1919             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
    1920             : #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
    1921             :     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
    1922             : #endif
    1923             :   };
    1924             : 
    1925             :   static PyTypeObject swigpyobject_type;
    1926             :   static int type_init = 0;
    1927         605 :   if (!type_init) {
    1928         605 :     const PyTypeObject tmp = {
    1929             : #if PY_VERSION_HEX >= 0x03000000
    1930             :       PyVarObject_HEAD_INIT(NULL, 0)
    1931             : #else
    1932             :       PyObject_HEAD_INIT(NULL)
    1933             :       0,                                    /* ob_size */
    1934             : #endif
    1935             :       (char *)"SwigPyObject",               /* tp_name */
    1936             :       sizeof(SwigPyObject),                 /* tp_basicsize */
    1937             :       0,                                    /* tp_itemsize */
    1938             :       (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
    1939             :       0,                                    /* tp_print */
    1940             : #if PY_VERSION_HEX < 0x02020000
    1941             :       (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
    1942             : #else
    1943             :       (getattrfunc)0,                       /* tp_getattr */
    1944             : #endif
    1945             :       (setattrfunc)0,                       /* tp_setattr */
    1946             : #if PY_VERSION_HEX >= 0x03000000
    1947             :       0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
    1948             : #else
    1949             :       (cmpfunc)SwigPyObject_compare,        /* tp_compare */
    1950             : #endif
    1951             :       (reprfunc)SwigPyObject_repr,          /* tp_repr */
    1952             :       &SwigPyObject_as_number,              /* tp_as_number */
    1953             :       0,                                    /* tp_as_sequence */
    1954             :       0,                                    /* tp_as_mapping */
    1955             :       (hashfunc)0,                          /* tp_hash */
    1956             :       (ternaryfunc)0,                       /* tp_call */
    1957             :       0,                                    /* tp_str */
    1958             :       PyObject_GenericGetAttr,              /* tp_getattro */
    1959             :       0,                                    /* tp_setattro */
    1960             :       0,                                    /* tp_as_buffer */
    1961             :       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
    1962             :       swigobject_doc,                       /* tp_doc */
    1963             :       0,                                    /* tp_traverse */
    1964             :       0,                                    /* tp_clear */
    1965             :       (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
    1966             :       0,                                    /* tp_weaklistoffset */
    1967             : #if PY_VERSION_HEX >= 0x02020000
    1968             :       0,                                    /* tp_iter */
    1969             :       0,                                    /* tp_iternext */
    1970             :       swigobject_methods,                   /* tp_methods */
    1971             :       0,                                    /* tp_members */
    1972             :       0,                                    /* tp_getset */
    1973             :       0,                                    /* tp_base */
    1974             :       0,                                    /* tp_dict */
    1975             :       0,                                    /* tp_descr_get */
    1976             :       0,                                    /* tp_descr_set */
    1977             :       0,                                    /* tp_dictoffset */
    1978             :       0,                                    /* tp_init */
    1979             :       0,                                    /* tp_alloc */
    1980             :       0,                                    /* tp_new */
    1981             :       0,                                    /* tp_free */
    1982             :       0,                                    /* tp_is_gc */
    1983             :       0,                                    /* tp_bases */
    1984             :       0,                                    /* tp_mro */
    1985             :       0,                                    /* tp_cache */
    1986             :       0,                                    /* tp_subclasses */
    1987             :       0,                                    /* tp_weaklist */
    1988             : #endif
    1989             : #if PY_VERSION_HEX >= 0x02030000
    1990             :       0,                                    /* tp_del */
    1991             : #endif
    1992             : #if PY_VERSION_HEX >= 0x02060000
    1993             :       0,                                    /* tp_version_tag */
    1994             : #endif
    1995             : #if PY_VERSION_HEX >= 0x03040000
    1996             :       0,                                    /* tp_finalize */
    1997             : #endif
    1998             : #ifdef COUNT_ALLOCS
    1999             :       0,                                    /* tp_allocs */
    2000             :       0,                                    /* tp_frees */
    2001             :       0,                                    /* tp_maxalloc */
    2002             : #if PY_VERSION_HEX >= 0x02050000
    2003             :       0,                                    /* tp_prev */
    2004             : #endif
    2005             :       0                                     /* tp_next */
    2006             : #endif
    2007             :     };
    2008         605 :     swigpyobject_type = tmp;
    2009         605 :     type_init = 1;
    2010             : #if PY_VERSION_HEX < 0x02020000
    2011             :     swigpyobject_type.ob_type = &PyType_Type;
    2012             : #else
    2013         605 :     if (PyType_Ready(&swigpyobject_type) < 0)
    2014           0 :       return NULL;
    2015             : #endif
    2016             :   }
    2017             :   return &swigpyobject_type;
    2018             : }
    2019             : 
    2020             : SWIGRUNTIME PyObject *
    2021      186846 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
    2022             : {
    2023      186846 :   SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
    2024      186846 :   if (sobj) {
    2025      186846 :     sobj->ptr  = ptr;
    2026      186846 :     sobj->ty   = ty;
    2027      186846 :     sobj->own  = own;
    2028      186846 :     sobj->next = 0;
    2029             :   }
    2030      186846 :   return (PyObject *)sobj;
    2031             : }
    2032             : 
    2033             : /* -----------------------------------------------------------------------------
    2034             :  * Implements a simple Swig Packed type, and use it instead of string
    2035             :  * ----------------------------------------------------------------------------- */
    2036             : 
    2037             : typedef struct {
    2038             :   PyObject_HEAD
    2039             :   void *pack;
    2040             :   swig_type_info *ty;
    2041             :   size_t size;
    2042             : } SwigPyPacked;
    2043             : 
    2044             : SWIGRUNTIME int
    2045           0 : SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
    2046             : {
    2047             :   char result[SWIG_BUFFER_SIZE];
    2048           0 :   fputs("<Swig Packed ", fp); 
    2049           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    2050           0 :     fputs("at ", fp); 
    2051           0 :     fputs(result, fp); 
    2052             :   }
    2053           0 :   fputs(v->ty->name,fp); 
    2054           0 :   fputs(">", fp);
    2055           0 :   return 0; 
    2056             : }
    2057             :   
    2058             : SWIGRUNTIME PyObject *
    2059           0 : SwigPyPacked_repr(SwigPyPacked *v)
    2060             : {
    2061             :   char result[SWIG_BUFFER_SIZE];
    2062           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    2063           0 :     return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
    2064             :   } else {
    2065           0 :     return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
    2066             :   }  
    2067             : }
    2068             : 
    2069             : SWIGRUNTIME PyObject *
    2070           0 : SwigPyPacked_str(SwigPyPacked *v)
    2071             : {
    2072             :   char result[SWIG_BUFFER_SIZE];
    2073           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    2074           0 :     return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
    2075             :   } else {
    2076           0 :     return SWIG_Python_str_FromChar(v->ty->name);
    2077             :   }  
    2078             : }
    2079             : 
    2080             : SWIGRUNTIME int
    2081           0 : SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
    2082             : {
    2083           0 :   size_t i = v->size;
    2084           0 :   size_t j = w->size;
    2085           0 :   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
    2086           0 :   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
    2087             : }
    2088             : 
    2089             : SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
    2090             : 
    2091             : SWIGRUNTIME PyTypeObject*
    2092           0 : SwigPyPacked_type(void) {
    2093           0 :   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
    2094           0 :   return type;
    2095             : }
    2096             : 
    2097             : SWIGRUNTIMEINLINE int
    2098           0 : SwigPyPacked_Check(PyObject *op) {
    2099           0 :   return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
    2100           0 :     || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
    2101             : }
    2102             : 
    2103             : SWIGRUNTIME void
    2104           0 : SwigPyPacked_dealloc(PyObject *v)
    2105             : {
    2106           0 :   if (SwigPyPacked_Check(v)) {
    2107           0 :     SwigPyPacked *sobj = (SwigPyPacked *) v;
    2108           0 :     free(sobj->pack);
    2109             :   }
    2110           0 :   PyObject_DEL(v);
    2111           0 : }
    2112             : 
    2113             : SWIGRUNTIME PyTypeObject*
    2114           0 : SwigPyPacked_TypeOnce(void) {
    2115             :   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
    2116             :   static PyTypeObject swigpypacked_type;
    2117             :   static int type_init = 0;
    2118           0 :   if (!type_init) {
    2119           0 :     const PyTypeObject tmp = {
    2120             : #if PY_VERSION_HEX>=0x03000000
    2121             :       PyVarObject_HEAD_INIT(NULL, 0)
    2122             : #else
    2123             :       PyObject_HEAD_INIT(NULL)
    2124             :       0,                                    /* ob_size */
    2125             : #endif
    2126             :       (char *)"SwigPyPacked",               /* tp_name */
    2127             :       sizeof(SwigPyPacked),                 /* tp_basicsize */
    2128             :       0,                                    /* tp_itemsize */
    2129             :       (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
    2130             :       (printfunc)SwigPyPacked_print,        /* tp_print */
    2131             :       (getattrfunc)0,                       /* tp_getattr */
    2132             :       (setattrfunc)0,                       /* tp_setattr */
    2133             : #if PY_VERSION_HEX>=0x03000000
    2134             :       0, /* tp_reserved in 3.0.1 */
    2135             : #else
    2136             :       (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
    2137             : #endif
    2138             :       (reprfunc)SwigPyPacked_repr,          /* tp_repr */
    2139             :       0,                                    /* tp_as_number */
    2140             :       0,                                    /* tp_as_sequence */
    2141             :       0,                                    /* tp_as_mapping */
    2142             :       (hashfunc)0,                          /* tp_hash */
    2143             :       (ternaryfunc)0,                       /* tp_call */
    2144             :       (reprfunc)SwigPyPacked_str,           /* tp_str */
    2145             :       PyObject_GenericGetAttr,              /* tp_getattro */
    2146             :       0,                                    /* tp_setattro */
    2147             :       0,                                    /* tp_as_buffer */
    2148             :       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
    2149             :       swigpacked_doc,                       /* tp_doc */
    2150             :       0,                                    /* tp_traverse */
    2151             :       0,                                    /* tp_clear */
    2152             :       0,                                    /* tp_richcompare */
    2153             :       0,                                    /* tp_weaklistoffset */
    2154             : #if PY_VERSION_HEX >= 0x02020000
    2155             :       0,                                    /* tp_iter */
    2156             :       0,                                    /* tp_iternext */
    2157             :       0,                                    /* tp_methods */
    2158             :       0,                                    /* tp_members */
    2159             :       0,                                    /* tp_getset */
    2160             :       0,                                    /* tp_base */
    2161             :       0,                                    /* tp_dict */
    2162             :       0,                                    /* tp_descr_get */
    2163             :       0,                                    /* tp_descr_set */
    2164             :       0,                                    /* tp_dictoffset */
    2165             :       0,                                    /* tp_init */
    2166             :       0,                                    /* tp_alloc */
    2167             :       0,                                    /* tp_new */
    2168             :       0,                                    /* tp_free */
    2169             :       0,                                    /* tp_is_gc */
    2170             :       0,                                    /* tp_bases */
    2171             :       0,                                    /* tp_mro */
    2172             :       0,                                    /* tp_cache */
    2173             :       0,                                    /* tp_subclasses */
    2174             :       0,                                    /* tp_weaklist */
    2175             : #endif
    2176             : #if PY_VERSION_HEX >= 0x02030000
    2177             :       0,                                    /* tp_del */
    2178             : #endif
    2179             : #if PY_VERSION_HEX >= 0x02060000
    2180             :       0,                                    /* tp_version_tag */
    2181             : #endif
    2182             : #if PY_VERSION_HEX >= 0x03040000
    2183             :       0,                                    /* tp_finalize */
    2184             : #endif
    2185             : #ifdef COUNT_ALLOCS
    2186             :       0,                                    /* tp_allocs */
    2187             :       0,                                    /* tp_frees */
    2188             :       0,                                    /* tp_maxalloc */
    2189             : #if PY_VERSION_HEX >= 0x02050000
    2190             :       0,                                    /* tp_prev */
    2191             : #endif
    2192             :       0                                     /* tp_next */
    2193             : #endif
    2194             :     };
    2195           0 :     swigpypacked_type = tmp;
    2196           0 :     type_init = 1;
    2197             : #if PY_VERSION_HEX < 0x02020000
    2198             :     swigpypacked_type.ob_type = &PyType_Type;
    2199             : #else
    2200           0 :     if (PyType_Ready(&swigpypacked_type) < 0)
    2201           0 :       return NULL;
    2202             : #endif
    2203             :   }
    2204             :   return &swigpypacked_type;
    2205             : }
    2206             : 
    2207             : SWIGRUNTIME PyObject *
    2208           0 : SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
    2209             : {
    2210           0 :   SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
    2211           0 :   if (sobj) {
    2212           0 :     void *pack = malloc(size);
    2213           0 :     if (pack) {
    2214           0 :       memcpy(pack, ptr, size);
    2215           0 :       sobj->pack = pack;
    2216           0 :       sobj->ty   = ty;
    2217           0 :       sobj->size = size;
    2218             :     } else {
    2219           0 :       PyObject_DEL((PyObject *) sobj);
    2220           0 :       sobj = 0;
    2221             :     }
    2222             :   }
    2223           0 :   return (PyObject *) sobj;
    2224             : }
    2225             : 
    2226             : SWIGRUNTIME swig_type_info *
    2227             : SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
    2228             : {
    2229             :   if (SwigPyPacked_Check(obj)) {
    2230             :     SwigPyPacked *sobj = (SwigPyPacked *)obj;
    2231             :     if (sobj->size != size) return 0;
    2232             :     memcpy(ptr, sobj->pack, size);
    2233             :     return sobj->ty;
    2234             :   } else {
    2235             :     return 0;
    2236             :   }
    2237             : }
    2238             : 
    2239             : /* -----------------------------------------------------------------------------
    2240             :  * pointers/data manipulation
    2241             :  * ----------------------------------------------------------------------------- */
    2242             : 
    2243             : SWIGRUNTIMEINLINE PyObject *
    2244             : _SWIG_This(void)
    2245             : {
    2246         605 :     return SWIG_Python_str_FromChar("this");
    2247             : }
    2248             : 
    2249             : static PyObject *swig_this = NULL;
    2250             : 
    2251             : SWIGRUNTIME PyObject *
    2252             : SWIG_This(void)
    2253             : {
    2254      333738 :   if (swig_this == NULL)
    2255         605 :     swig_this = _SWIG_This();
    2256      333738 :   return swig_this;
    2257             : }
    2258             : 
    2259             : /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
    2260             : 
    2261             : /* TODO: I don't know how to implement the fast getset in Python 3 right now */
    2262             : #if PY_VERSION_HEX>=0x03000000
    2263             : #define SWIG_PYTHON_SLOW_GETSET_THIS 
    2264             : #endif
    2265             : 
    2266             : SWIGRUNTIME SwigPyObject *
    2267      337395 : SWIG_Python_GetSwigThis(PyObject *pyobj) 
    2268             : {
    2269             :   PyObject *obj;
    2270             : 
    2271      337395 :   if (SwigPyObject_Check(pyobj))
    2272             :     return (SwigPyObject *) pyobj;
    2273             : 
    2274             : #ifdef SWIGPYTHON_BUILTIN
    2275             :   (void)obj;
    2276             : # ifdef PyWeakref_CheckProxy
    2277             :   if (PyWeakref_CheckProxy(pyobj)) {
    2278             :     pyobj = PyWeakref_GET_OBJECT(pyobj);
    2279             :     if (pyobj && SwigPyObject_Check(pyobj))
    2280             :       return (SwigPyObject*) pyobj;
    2281             :   }
    2282             : # endif
    2283             :   return NULL;
    2284             : #else
    2285             : 
    2286      245756 :   obj = 0;
    2287             : 
    2288             : #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
    2289      245756 :   if (PyInstance_Check(pyobj)) {
    2290           0 :     obj = _PyInstance_Lookup(pyobj, SWIG_This());      
    2291             :   } else {
    2292      245756 :     PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    2293      245756 :     if (dictptr != NULL) {
    2294      245351 :       PyObject *dict = *dictptr;
    2295      490702 :       obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    2296             :     } else {
    2297             : #ifdef PyWeakref_CheckProxy
    2298         405 :       if (PyWeakref_CheckProxy(pyobj)) {
    2299           0 :         PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
    2300           0 :         return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
    2301             :       }
    2302             : #endif
    2303         405 :       obj = PyObject_GetAttr(pyobj,SWIG_This());
    2304         405 :       if (obj) {
    2305           0 :         Py_DECREF(obj);
    2306             :       } else {
    2307         405 :         if (PyErr_Occurred()) PyErr_Clear();
    2308             :         return 0;
    2309             :       }
    2310             :     }
    2311             :   }
    2312             : #else
    2313             :   obj = PyObject_GetAttr(pyobj,SWIG_This());
    2314             :   if (obj) {
    2315             :     Py_DECREF(obj);
    2316             :   } else {
    2317             :     if (PyErr_Occurred()) PyErr_Clear();
    2318             :     return 0;
    2319             :   }
    2320             : #endif
    2321      245351 :   if (obj && !SwigPyObject_Check(obj)) {
    2322             :     /* a PyObject is called 'this', try to get the 'real this'
    2323             :        SwigPyObject from it */ 
    2324             :     return SWIG_Python_GetSwigThis(obj);
    2325             :   }
    2326             :   return (SwigPyObject *)obj;
    2327             : #endif
    2328             : }
    2329             : 
    2330             : /* Acquire a pointer value */
    2331             : 
    2332             : SWIGRUNTIME int
    2333             : SWIG_Python_AcquirePtr(PyObject *obj, int own) {
    2334             :   if (own == SWIG_POINTER_OWN) {
    2335             :     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    2336             :     if (sobj) {
    2337             :       int oldown = sobj->own;
    2338             :       sobj->own = own;
    2339             :       return oldown;
    2340             :     }
    2341             :   }
    2342             :   return 0;
    2343             : }
    2344             : 
    2345             : /* Convert a pointer value */
    2346             : 
    2347             : SWIGRUNTIME int
    2348      337648 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
    2349             :   int res;
    2350             :   SwigPyObject *sobj;
    2351      337648 :   int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
    2352             : 
    2353      337648 :   if (!obj)
    2354             :     return SWIG_ERROR;
    2355      337648 :   if (obj == Py_None && !implicit_conv) {
    2356         253 :     if (ptr)
    2357         253 :       *ptr = 0;
    2358             :     return SWIG_OK;
    2359             :   }
    2360             : 
    2361      337395 :   res = SWIG_ERROR;
    2362             : 
    2363      337395 :   sobj = SWIG_Python_GetSwigThis(obj);
    2364      337395 :   if (own)
    2365           0 :     *own = 0;
    2366      337397 :   while (sobj) {
    2367      336990 :     void *vptr = sobj->ptr;
    2368      336990 :     if (ty) {
    2369      336990 :       swig_type_info *to = sobj->ty;
    2370      336990 :       if (to == ty) {
    2371             :         /* no type cast needed */
    2372      336988 :         if (ptr) *ptr = vptr;
    2373             :         break;
    2374             :       } else {
    2375           2 :         swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
    2376           2 :         if (!tc) {
    2377           2 :           sobj = (SwigPyObject *)sobj->next;
    2378             :         } else {
    2379           0 :           if (ptr) {
    2380           0 :             int newmemory = 0;
    2381           0 :             *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
    2382           0 :             if (newmemory == SWIG_CAST_NEW_MEMORY) {
    2383             :               assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
    2384           0 :               if (own)
    2385           0 :                 *own = *own | SWIG_CAST_NEW_MEMORY;
    2386             :             }
    2387             :           }
    2388             :           break;
    2389             :         }
    2390             :       }
    2391             :     } else {
    2392           0 :       if (ptr) *ptr = vptr;
    2393             :       break;
    2394             :     }
    2395             :   }
    2396      337395 :   if (sobj) {
    2397      336988 :     if (own)
    2398           0 :       *own = *own | sobj->own;
    2399      336988 :     if (flags & SWIG_POINTER_DISOWN) {
    2400       91639 :       sobj->own = 0;
    2401             :     }
    2402             :     res = SWIG_OK;
    2403             :   } else {
    2404         407 :     if (implicit_conv) {
    2405           0 :       SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    2406           0 :       if (data && !data->implicitconv) {
    2407           0 :         PyObject *klass = data->klass;
    2408           0 :         if (klass) {
    2409             :           PyObject *impconv;
    2410           0 :           data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
    2411           0 :           impconv = SWIG_Python_CallFunctor(klass, obj);
    2412           0 :           data->implicitconv = 0;
    2413           0 :           if (PyErr_Occurred()) {
    2414           0 :             PyErr_Clear();
    2415           0 :             impconv = 0;
    2416             :           }
    2417           0 :           if (impconv) {
    2418           0 :             SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
    2419           0 :             if (iobj) {
    2420             :               void *vptr;
    2421           0 :               res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
    2422           0 :               if (SWIG_IsOK(res)) {
    2423           0 :                 if (ptr) {
    2424           0 :                   *ptr = vptr;
    2425             :                   /* transfer the ownership to 'ptr' */
    2426           0 :                   iobj->own = 0;
    2427           0 :                   res = SWIG_AddCast(res);
    2428           0 :                   res = SWIG_AddNewMask(res);
    2429             :                 } else {
    2430             :                   res = SWIG_AddCast(res);                  
    2431             :                 }
    2432             :               }
    2433             :             }
    2434           0 :             Py_DECREF(impconv);
    2435             :           }
    2436             :         }
    2437             :       }
    2438             :     }
    2439           0 :     if (!SWIG_IsOK(res) && obj == Py_None) {
    2440           0 :       if (ptr)
    2441           0 :         *ptr = 0;
    2442           0 :       if (PyErr_Occurred())
    2443           0 :         PyErr_Clear();
    2444             :       res = SWIG_OK;
    2445             :     }
    2446             :   }
    2447             :   return res;
    2448             : }
    2449             : 
    2450             : /* Convert a function ptr value */
    2451             : 
    2452             : SWIGRUNTIME int
    2453           1 : SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
    2454           1 :   if (!PyCFunction_Check(obj)) {
    2455           1 :     return SWIG_ConvertPtr(obj, ptr, ty, 0);
    2456             :   } else {
    2457           0 :     void *vptr = 0;
    2458             :     
    2459             :     /* here we get the method pointer for callbacks */
    2460           0 :     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
    2461           0 :     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    2462           0 :     if (desc)
    2463           0 :       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
    2464           0 :     if (!desc) 
    2465             :       return SWIG_ERROR;
    2466           0 :     if (ty) {
    2467           0 :       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
    2468           0 :       if (tc) {
    2469           0 :         int newmemory = 0;
    2470           0 :         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
    2471             :         assert(!newmemory); /* newmemory handling not yet implemented */
    2472             :       } else {
    2473             :         return SWIG_ERROR;
    2474             :       }
    2475             :     } else {
    2476           0 :       *ptr = vptr;
    2477             :     }
    2478             :     return SWIG_OK;
    2479             :   }
    2480             : }
    2481             : 
    2482             : /* Convert a packed value value */
    2483             : 
    2484             : SWIGRUNTIME int
    2485             : SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
    2486             :   swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
    2487             :   if (!to) return SWIG_ERROR;
    2488             :   if (ty) {
    2489             :     if (to != ty) {
    2490             :       /* check type cast? */
    2491             :       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
    2492             :       if (!tc) return SWIG_ERROR;
    2493             :     }
    2494             :   }
    2495             :   return SWIG_OK;
    2496             : }  
    2497             : 
    2498             : /* -----------------------------------------------------------------------------
    2499             :  * Create a new pointer object
    2500             :  * ----------------------------------------------------------------------------- */
    2501             : 
    2502             : /*
    2503             :   Create a new instance object, without calling __init__, and set the
    2504             :   'this' attribute.
    2505             : */
    2506             : 
    2507             : SWIGRUNTIME PyObject* 
    2508       87377 : SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
    2509             : {
    2510             : #if (PY_VERSION_HEX >= 0x02020000)
    2511       87377 :   PyObject *inst = 0;
    2512       87377 :   PyObject *newraw = data->newraw;
    2513       87377 :   if (newraw) {
    2514       87377 :     inst = PyObject_Call(newraw, data->newargs, NULL);
    2515       87377 :     if (inst) {
    2516             : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
    2517       87377 :       PyObject **dictptr = _PyObject_GetDictPtr(inst);
    2518       87377 :       if (dictptr != NULL) {
    2519       87377 :         PyObject *dict = *dictptr;
    2520       87377 :         if (dict == NULL) {
    2521       87377 :           dict = PyDict_New();
    2522       87377 :           *dictptr = dict;
    2523       87377 :           PyDict_SetItem(dict, SWIG_This(), swig_this);
    2524             :         }
    2525             :       }
    2526             : #else
    2527             :       PyObject *key = SWIG_This();
    2528             :       PyObject_SetAttr(inst, key, swig_this);
    2529             : #endif
    2530             :     }
    2531             :   } else {
    2532             : #if PY_VERSION_HEX >= 0x03000000
    2533             :     inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
    2534             :     if (inst) {
    2535             :       PyObject_SetAttr(inst, SWIG_This(), swig_this);
    2536             :       Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
    2537             :     }
    2538             : #else
    2539           0 :     PyObject *dict = PyDict_New();
    2540           0 :     if (dict) {
    2541           0 :       PyDict_SetItem(dict, SWIG_This(), swig_this);
    2542           0 :       inst = PyInstance_NewRaw(data->newargs, dict);
    2543           0 :       Py_DECREF(dict);
    2544             :     }
    2545             : #endif
    2546             :   }
    2547       87377 :   return inst;
    2548             : #else
    2549             : #if (PY_VERSION_HEX >= 0x02010000)
    2550             :   PyObject *inst = 0;
    2551             :   PyObject *dict = PyDict_New();
    2552             :   if (dict) {
    2553             :     PyDict_SetItem(dict, SWIG_This(), swig_this);
    2554             :     inst = PyInstance_NewRaw(data->newargs, dict);
    2555             :     Py_DECREF(dict);
    2556             :   }
    2557             :   return (PyObject *) inst;
    2558             : #else
    2559             :   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
    2560             :   if (inst == NULL) {
    2561             :     return NULL;
    2562             :   }
    2563             :   inst->in_class = (PyClassObject *)data->newargs;
    2564             :   Py_INCREF(inst->in_class);
    2565             :   inst->in_dict = PyDict_New();
    2566             :   if (inst->in_dict == NULL) {
    2567             :     Py_DECREF(inst);
    2568             :     return NULL;
    2569             :   }
    2570             : #ifdef Py_TPFLAGS_HAVE_WEAKREFS
    2571             :   inst->in_weakreflist = NULL;
    2572             : #endif
    2573             : #ifdef Py_TPFLAGS_GC
    2574             :   PyObject_GC_Init(inst);
    2575             : #endif
    2576             :   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
    2577             :   return (PyObject *) inst;
    2578             : #endif
    2579             : #endif
    2580             : }
    2581             : 
    2582             : SWIGRUNTIME void
    2583             : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
    2584             : {
    2585             :  PyObject *dict;
    2586             : #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
    2587             :  PyObject **dictptr = _PyObject_GetDictPtr(inst);
    2588             :  if (dictptr != NULL) {
    2589             :    dict = *dictptr;
    2590             :    if (dict == NULL) {
    2591             :      dict = PyDict_New();
    2592             :      *dictptr = dict;
    2593             :    }
    2594             :    PyDict_SetItem(dict, SWIG_This(), swig_this);
    2595             :    return;
    2596             :  }
    2597             : #endif
    2598             :  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
    2599             :  PyDict_SetItem(dict, SWIG_This(), swig_this);
    2600             :  Py_DECREF(dict);
    2601             : } 
    2602             : 
    2603             : 
    2604             : SWIGINTERN PyObject *
    2605             : SWIG_Python_InitShadowInstance(PyObject *args) {
    2606             :   PyObject *obj[2];
    2607             :   if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    2608             :     return NULL;
    2609             :   } else {
    2610             :     SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    2611             :     if (sthis) {
    2612             :       SwigPyObject_append((PyObject*) sthis, obj[1]);
    2613             :     } else {
    2614             :       SWIG_Python_SetSwigThis(obj[0], obj[1]);
    2615             :     }
    2616             :     return SWIG_Py_Void();
    2617             :   }
    2618             : }
    2619             : 
    2620             : /* Create a new pointer object */
    2621             : 
    2622             : SWIGRUNTIME PyObject *
    2623       95208 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
    2624             :   SwigPyClientData *clientdata;
    2625             :   PyObject * robj;
    2626             :   int own;
    2627             : 
    2628       95208 :   if (!ptr)
    2629           1 :     return SWIG_Py_Void();
    2630             : 
    2631      190414 :   clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
    2632       95207 :   own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
    2633       95207 :   if (clientdata && clientdata->pytype) {
    2634             :     SwigPyObject *newobj;
    2635           0 :     if (flags & SWIG_BUILTIN_TP_INIT) {
    2636           0 :       newobj = (SwigPyObject*) self;
    2637           0 :       if (newobj->ptr) {
    2638           0 :         PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
    2639           0 :         while (newobj->next)
    2640             :           newobj = (SwigPyObject *) newobj->next;
    2641           0 :         newobj->next = next_self;
    2642           0 :         newobj = (SwigPyObject *)next_self;
    2643             : #ifdef SWIGPYTHON_BUILTIN
    2644             :         newobj->dict = 0;
    2645             : #endif
    2646             :       }
    2647             :     } else {
    2648           0 :       newobj = PyObject_New(SwigPyObject, clientdata->pytype);
    2649             : #ifdef SWIGPYTHON_BUILTIN
    2650             :       newobj->dict = 0;
    2651             : #endif
    2652             :     }
    2653           0 :     if (newobj) {
    2654           0 :       newobj->ptr = ptr;
    2655           0 :       newobj->ty = type;
    2656           0 :       newobj->own = own;
    2657           0 :       newobj->next = 0;
    2658           0 :       return (PyObject*) newobj;
    2659             :     }
    2660           0 :     return SWIG_Py_Void();
    2661             :   }
    2662             : 
    2663             :   assert(!(flags & SWIG_BUILTIN_TP_INIT));
    2664             : 
    2665       95207 :   robj = SwigPyObject_New(ptr, type, own);
    2666       95207 :   if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    2667       87377 :     PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    2668       87377 :     Py_DECREF(robj);
    2669             :     robj = inst;
    2670             :   }
    2671             :   return robj;
    2672             : }
    2673             : 
    2674             : /* Create a new packed object */
    2675             : 
    2676             : SWIGRUNTIMEINLINE PyObject *
    2677             : SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
    2678           0 :   return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
    2679             : }
    2680             : 
    2681             : /* -----------------------------------------------------------------------------*
    2682             :  *  Get type list 
    2683             :  * -----------------------------------------------------------------------------*/
    2684             : 
    2685             : #ifdef SWIG_LINK_RUNTIME
    2686             : void *SWIG_ReturnGlobalTypeList(void *);
    2687             : #endif
    2688             : 
    2689             : SWIGRUNTIME swig_module_info *
    2690         616 : SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
    2691             :   static void *type_pointer = (void *)0;
    2692             :   /* first check if module already created */
    2693         616 :   if (!type_pointer) {
    2694             : #ifdef SWIG_LINK_RUNTIME
    2695             :     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
    2696             : #else
    2697             : # ifdef SWIGPY_USE_CAPSULE
    2698         616 :     type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
    2699             : # else
    2700             :     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
    2701             :                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
    2702             : # endif
    2703         616 :     if (PyErr_Occurred()) {
    2704         605 :       PyErr_Clear();
    2705         605 :       type_pointer = (void *)0;
    2706             :     }
    2707             : #endif
    2708             :   }
    2709         616 :   return (swig_module_info *) type_pointer;
    2710             : }
    2711             : 
    2712             : #if PY_MAJOR_VERSION < 2
    2713             : /* PyModule_AddObject function was introduced in Python 2.0.  The following function
    2714             :    is copied out of Python/modsupport.c in python version 2.3.4 */
    2715             : SWIGINTERN int
    2716             : PyModule_AddObject(PyObject *m, char *name, PyObject *o)
    2717             : {
    2718             :   PyObject *dict;
    2719             :   if (!PyModule_Check(m)) {
    2720             :     PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
    2721             :     return SWIG_ERROR;
    2722             :   }
    2723             :   if (!o) {
    2724             :     PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
    2725             :     return SWIG_ERROR;
    2726             :   }
    2727             :   
    2728             :   dict = PyModule_GetDict(m);
    2729             :   if (dict == NULL) {
    2730             :     /* Internal error -- modules must have a dict! */
    2731             :     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
    2732             :                  PyModule_GetName(m));
    2733             :     return SWIG_ERROR;
    2734             :   }
    2735             :   if (PyDict_SetItemString(dict, name, o))
    2736             :     return SWIG_ERROR;
    2737             :   Py_DECREF(o);
    2738             :   return SWIG_OK;
    2739             : }
    2740             : #endif
    2741             : 
    2742             : SWIGRUNTIME void
    2743             : #ifdef SWIGPY_USE_CAPSULE
    2744         605 : SWIG_Python_DestroyModule(PyObject *obj)
    2745             : #else
    2746             : SWIG_Python_DestroyModule(void *vptr)
    2747             : #endif
    2748             : {
    2749             : #ifdef SWIGPY_USE_CAPSULE
    2750         605 :   swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
    2751             : #else
    2752             :   swig_module_info *swig_module = (swig_module_info *) vptr;
    2753             : #endif
    2754         605 :   swig_type_info **types = swig_module->types;
    2755             :   size_t i;
    2756      153670 :   for (i =0; i < swig_module->size; ++i) {
    2757      153065 :     swig_type_info *ty = types[i];
    2758      153065 :     if (ty->owndata) {
    2759       44770 :       SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
    2760       44770 :       if (data) SwigPyClientData_Del(data);
    2761             :     }
    2762             :   }
    2763         605 :   Py_DECREF(SWIG_This());
    2764         605 :   swig_this = NULL;
    2765         605 : }
    2766             : 
    2767             : SWIGRUNTIME void
    2768         605 : SWIG_Python_SetModule(swig_module_info *swig_module) {
    2769             : #if PY_VERSION_HEX >= 0x03000000
    2770             :  /* Add a dummy module object into sys.modules */
    2771             :   PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
    2772             : #else
    2773             :   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
    2774         605 :   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
    2775             : #endif
    2776             : #ifdef SWIGPY_USE_CAPSULE
    2777         605 :   PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
    2778         605 :   if (pointer && module) {
    2779         605 :     PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
    2780             :   } else {
    2781           0 :     Py_XDECREF(pointer);
    2782             :   }
    2783             : #else
    2784             :   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
    2785             :   if (pointer && module) {
    2786             :     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
    2787             :   } else {
    2788             :     Py_XDECREF(pointer);
    2789             :   }
    2790             : #endif
    2791         605 : }
    2792             : 
    2793             : /* The python cached type query */
    2794             : SWIGRUNTIME PyObject *
    2795             : SWIG_Python_TypeCache(void) {
    2796             :   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
    2797             :   return cache;
    2798             : }
    2799             : 
    2800             : SWIGRUNTIME swig_type_info *
    2801             : SWIG_Python_TypeQuery(const char *type)
    2802             : {
    2803             :   PyObject *cache = SWIG_Python_TypeCache();
    2804             :   PyObject *key = SWIG_Python_str_FromChar(type); 
    2805             :   PyObject *obj = PyDict_GetItem(cache, key);
    2806             :   swig_type_info *descriptor;
    2807             :   if (obj) {
    2808             : #ifdef SWIGPY_USE_CAPSULE
    2809             :     descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
    2810             : #else
    2811             :     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
    2812             : #endif
    2813             :   } else {
    2814             :     swig_module_info *swig_module = SWIG_GetModule(0);
    2815             :     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    2816             :     if (descriptor) {
    2817             : #ifdef SWIGPY_USE_CAPSULE
    2818             :       obj = PyCapsule_New((void*) descriptor, NULL, NULL);
    2819             : #else
    2820             :       obj = PyCObject_FromVoidPtr(descriptor, NULL);
    2821             : #endif
    2822             :       PyDict_SetItem(cache, key, obj);
    2823             :       Py_DECREF(obj);
    2824             :     }
    2825             :   }
    2826             :   Py_DECREF(key);
    2827             :   return descriptor;
    2828             : }
    2829             : 
    2830             : /* 
    2831             :    For backward compatibility only
    2832             : */
    2833             : #define SWIG_POINTER_EXCEPTION  0
    2834             : #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
    2835             : #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
    2836             : 
    2837             : SWIGRUNTIME int
    2838             : SWIG_Python_AddErrMesg(const char* mesg, int infront)
    2839             : {  
    2840             :   if (PyErr_Occurred()) {
    2841             :     PyObject *type = 0;
    2842             :     PyObject *value = 0;
    2843             :     PyObject *traceback = 0;
    2844             :     PyErr_Fetch(&type, &value, &traceback);
    2845             :     if (value) {
    2846             :       char *tmp;
    2847             :       PyObject *old_str = PyObject_Str(value);
    2848             :       Py_XINCREF(type);
    2849             :       PyErr_Clear();
    2850             :       if (infront) {
    2851             :         PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
    2852             :       } else {
    2853             :         PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    2854             :       }
    2855             :       SWIG_Python_str_DelForPy3(tmp);
    2856             :       Py_DECREF(old_str);
    2857             :     }
    2858             :     return 1;
    2859             :   } else {
    2860             :     return 0;
    2861             :   }
    2862             : }
    2863             :   
    2864             : SWIGRUNTIME int
    2865             : SWIG_Python_ArgFail(int argnum)
    2866             : {
    2867             :   if (PyErr_Occurred()) {
    2868             :     /* add information about failing argument */
    2869             :     char mesg[256];
    2870             :     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    2871             :     return SWIG_Python_AddErrMesg(mesg, 1);
    2872             :   } else {
    2873             :     return 0;
    2874             :   }
    2875             : }
    2876             : 
    2877             : SWIGRUNTIMEINLINE const char *
    2878             : SwigPyObject_GetDesc(PyObject *self)
    2879             : {
    2880             :   SwigPyObject *v = (SwigPyObject *)self;
    2881             :   swig_type_info *ty = v ? v->ty : 0;
    2882             :   return ty ? ty->str : "";
    2883             : }
    2884             : 
    2885             : SWIGRUNTIME void
    2886             : SWIG_Python_TypeError(const char *type, PyObject *obj)
    2887             : {
    2888             :   if (type) {
    2889             : #if defined(SWIG_COBJECT_TYPES)
    2890             :     if (obj && SwigPyObject_Check(obj)) {
    2891             :       const char *otype = (const char *) SwigPyObject_GetDesc(obj);
    2892             :       if (otype) {
    2893             :         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
    2894             :                      type, otype);
    2895             :         return;
    2896             :       }
    2897             :     } else 
    2898             : #endif      
    2899             :     {
    2900             :       const char *otype = (obj ? obj->ob_type->tp_name : 0); 
    2901             :       if (otype) {
    2902             :         PyObject *str = PyObject_Str(obj);
    2903             :         const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
    2904             :         if (cstr) {
    2905             :           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
    2906             :                        type, otype, cstr);
    2907             :           SWIG_Python_str_DelForPy3(cstr);
    2908             :         } else {
    2909             :           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
    2910             :                        type, otype);
    2911             :         }
    2912             :         Py_XDECREF(str);
    2913             :         return;
    2914             :       }
    2915             :     }   
    2916             :     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
    2917             :   } else {
    2918             :     PyErr_Format(PyExc_TypeError, "unexpected type is received");
    2919             :   }
    2920             : }
    2921             : 
    2922             : 
    2923             : /* Convert a pointer value, signal an exception on a type mismatch */
    2924             : SWIGRUNTIME void *
    2925             : SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
    2926             :   void *result;
    2927             :   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    2928             :     PyErr_Clear();
    2929             : #if SWIG_POINTER_EXCEPTION
    2930             :     if (flags) {
    2931             :       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
    2932             :       SWIG_Python_ArgFail(argnum);
    2933             :     }
    2934             : #endif
    2935             :   }
    2936             :   return result;
    2937             : }
    2938             : 
    2939             : #ifdef SWIGPYTHON_BUILTIN
    2940             : SWIGRUNTIME int
    2941             : SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
    2942             :   PyTypeObject *tp = obj->ob_type;
    2943             :   PyObject *descr;
    2944             :   PyObject *encoded_name;
    2945             :   descrsetfunc f;
    2946             :   int res = -1;
    2947             : 
    2948             : # ifdef Py_USING_UNICODE
    2949             :   if (PyString_Check(name)) {
    2950             :     name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    2951             :     if (!name)
    2952             :       return -1;
    2953             :   } else if (!PyUnicode_Check(name))
    2954             : # else
    2955             :   if (!PyString_Check(name))
    2956             : # endif
    2957             :   {
    2958             :     PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    2959             :     return -1;
    2960             :   } else {
    2961             :     Py_INCREF(name);
    2962             :   }
    2963             : 
    2964             :   if (!tp->tp_dict) {
    2965             :     if (PyType_Ready(tp) < 0)
    2966             :       goto done;
    2967             :   }
    2968             : 
    2969             :   descr = _PyType_Lookup(tp, name);
    2970             :   f = NULL;
    2971             :   if (descr != NULL)
    2972             :     f = descr->ob_type->tp_descr_set;
    2973             :   if (!f) {
    2974             :     if (PyString_Check(name)) {
    2975             :       encoded_name = name;
    2976             :       Py_INCREF(name);
    2977             :     } else {
    2978             :       encoded_name = PyUnicode_AsUTF8String(name);
    2979             :     }
    2980             :     PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    2981             :     Py_DECREF(encoded_name);
    2982             :   } else {
    2983             :     res = f(descr, obj, value);
    2984             :   }
    2985             :   
    2986             :   done:
    2987             :   Py_DECREF(name);
    2988             :   return res;
    2989             : }
    2990             : #endif
    2991             : 
    2992             : 
    2993             : #ifdef __cplusplus
    2994             : }
    2995             : #endif
    2996             : 
    2997             : 
    2998             : 
    2999             : #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
    3000             : 
    3001             : #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
    3002             : 
    3003             : 
    3004             : 
    3005             : // Forward declaration to be inserted at the start of LLDBWrapPython.h
    3006             : #include "lldb/API/SBDebugger.h"
    3007             : #include "lldb/API/SBValue.h"
    3008             : 
    3009             : SWIGEXPORT lldb::ValueObjectSP
    3010           0 : LLDBSWIGPython_GetValueObjectSPFromSBValue (void* data)
    3011             : {
    3012           0 :     lldb::ValueObjectSP valobj_sp;
    3013           0 :     if (data)
    3014             :     {
    3015           0 :         lldb::SBValue* sb_ptr = (lldb::SBValue *)data;
    3016           0 :         valobj_sp = sb_ptr->GetSP();
    3017             :     }
    3018           0 :     return valobj_sp;
    3019             : }
    3020             : 
    3021             : #ifdef __cplusplus
    3022             : extern "C" {
    3023             : #endif
    3024             : 
    3025             : void LLDBSwigPythonCallPythonLogOutputCallback(const char *str, void *baton);
    3026             : 
    3027             : #ifdef __cplusplus
    3028             : }
    3029             : #endif
    3030             : 
    3031             : 
    3032             : /* -------- TYPES TABLE (BEGIN) -------- */
    3033             : 
    3034             : #define SWIGTYPE_p_FILE swig_types[0]
    3035             : #define SWIGTYPE_p_bool swig_types[1]
    3036             : #define SWIGTYPE_p_char swig_types[2]
    3037             : #define SWIGTYPE_p_double swig_types[3]
    3038             : #define SWIGTYPE_p_f_p_void__p_void swig_types[4]
    3039             : #define SWIGTYPE_p_f_p_void_p_q_const__void_size_t__void swig_types[5]
    3040             : #define SWIGTYPE_p_int swig_types[6]
    3041             : #define SWIGTYPE_p_lldb__ConnectionStatus swig_types[7]
    3042             : #define SWIGTYPE_p_lldb__SBAddress swig_types[8]
    3043             : #define SWIGTYPE_p_lldb__SBAttachInfo swig_types[9]
    3044             : #define SWIGTYPE_p_lldb__SBBlock swig_types[10]
    3045             : #define SWIGTYPE_p_lldb__SBBreakpoint swig_types[11]
    3046             : #define SWIGTYPE_p_lldb__SBBreakpointList swig_types[12]
    3047             : #define SWIGTYPE_p_lldb__SBBreakpointLocation swig_types[13]
    3048             : #define SWIGTYPE_p_lldb__SBBroadcaster swig_types[14]
    3049             : #define SWIGTYPE_p_lldb__SBCommandInterpreter swig_types[15]
    3050             : #define SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions swig_types[16]
    3051             : #define SWIGTYPE_p_lldb__SBCommandReturnObject swig_types[17]
    3052             : #define SWIGTYPE_p_lldb__SBCommunication swig_types[18]
    3053             : #define SWIGTYPE_p_lldb__SBCompileUnit swig_types[19]
    3054             : #define SWIGTYPE_p_lldb__SBData swig_types[20]
    3055             : #define SWIGTYPE_p_lldb__SBDebugger swig_types[21]
    3056             : #define SWIGTYPE_p_lldb__SBDeclaration swig_types[22]
    3057             : #define SWIGTYPE_p_lldb__SBError swig_types[23]
    3058             : #define SWIGTYPE_p_lldb__SBEvent swig_types[24]
    3059             : #define SWIGTYPE_p_lldb__SBExecutionContext swig_types[25]
    3060             : #define SWIGTYPE_p_lldb__SBExpressionOptions swig_types[26]
    3061             : #define SWIGTYPE_p_lldb__SBFileSpec swig_types[27]
    3062             : #define SWIGTYPE_p_lldb__SBFileSpecList swig_types[28]
    3063             : #define SWIGTYPE_p_lldb__SBFrame swig_types[29]
    3064             : #define SWIGTYPE_p_lldb__SBFunction swig_types[30]
    3065             : #define SWIGTYPE_p_lldb__SBHostOS swig_types[31]
    3066             : #define SWIGTYPE_p_lldb__SBInstruction swig_types[32]
    3067             : #define SWIGTYPE_p_lldb__SBInstructionList swig_types[33]
    3068             : #define SWIGTYPE_p_lldb__SBLanguageRuntime swig_types[34]
    3069             : #define SWIGTYPE_p_lldb__SBLaunchInfo swig_types[35]
    3070             : #define SWIGTYPE_p_lldb__SBLineEntry swig_types[36]
    3071             : #define SWIGTYPE_p_lldb__SBListener swig_types[37]
    3072             : #define SWIGTYPE_p_lldb__SBMemoryRegionInfo swig_types[38]
    3073             : #define SWIGTYPE_p_lldb__SBMemoryRegionInfoList swig_types[39]
    3074             : #define SWIGTYPE_p_lldb__SBModule swig_types[40]
    3075             : #define SWIGTYPE_p_lldb__SBModuleSpec swig_types[41]
    3076             : #define SWIGTYPE_p_lldb__SBModuleSpecList swig_types[42]
    3077             : #define SWIGTYPE_p_lldb__SBPlatform swig_types[43]
    3078             : #define SWIGTYPE_p_lldb__SBPlatformConnectOptions swig_types[44]
    3079             : #define SWIGTYPE_p_lldb__SBPlatformShellCommand swig_types[45]
    3080             : #define SWIGTYPE_p_lldb__SBProcess swig_types[46]
    3081             : #define SWIGTYPE_p_lldb__SBProcessInfo swig_types[47]
    3082             : #define SWIGTYPE_p_lldb__SBQueue swig_types[48]
    3083             : #define SWIGTYPE_p_lldb__SBQueueItem swig_types[49]
    3084             : #define SWIGTYPE_p_lldb__SBSection swig_types[50]
    3085             : #define SWIGTYPE_p_lldb__SBSourceManager swig_types[51]
    3086             : #define SWIGTYPE_p_lldb__SBStream swig_types[52]
    3087             : #define SWIGTYPE_p_lldb__SBStringList swig_types[53]
    3088             : #define SWIGTYPE_p_lldb__SBStructuredData swig_types[54]
    3089             : #define SWIGTYPE_p_lldb__SBSymbol swig_types[55]
    3090             : #define SWIGTYPE_p_lldb__SBSymbolContext swig_types[56]
    3091             : #define SWIGTYPE_p_lldb__SBSymbolContextList swig_types[57]
    3092             : #define SWIGTYPE_p_lldb__SBTarget swig_types[58]
    3093             : #define SWIGTYPE_p_lldb__SBThread swig_types[59]
    3094             : #define SWIGTYPE_p_lldb__SBThreadCollection swig_types[60]
    3095             : #define SWIGTYPE_p_lldb__SBThreadPlan swig_types[61]
    3096             : #define SWIGTYPE_p_lldb__SBTrace swig_types[62]
    3097             : #define SWIGTYPE_p_lldb__SBTraceOptions swig_types[63]
    3098             : #define SWIGTYPE_p_lldb__SBType swig_types[64]
    3099             : #define SWIGTYPE_p_lldb__SBTypeCategory swig_types[65]
    3100             : #define SWIGTYPE_p_lldb__SBTypeEnumMember swig_types[66]
    3101             : #define SWIGTYPE_p_lldb__SBTypeEnumMemberList swig_types[67]
    3102             : #define SWIGTYPE_p_lldb__SBTypeFilter swig_types[68]
    3103             : #define SWIGTYPE_p_lldb__SBTypeFormat swig_types[69]
    3104             : #define SWIGTYPE_p_lldb__SBTypeList swig_types[70]
    3105             : #define SWIGTYPE_p_lldb__SBTypeMember swig_types[71]
    3106             : #define SWIGTYPE_p_lldb__SBTypeMemberFunction swig_types[72]
    3107             : #define SWIGTYPE_p_lldb__SBTypeNameSpecifier swig_types[73]
    3108             : #define SWIGTYPE_p_lldb__SBTypeSummary swig_types[74]
    3109             : #define SWIGTYPE_p_lldb__SBTypeSummaryOptions swig_types[75]
    3110             : #define SWIGTYPE_p_lldb__SBTypeSynthetic swig_types[76]
    3111             : #define SWIGTYPE_p_lldb__SBUnixSignals swig_types[77]
    3112             : #define SWIGTYPE_p_lldb__SBValue swig_types[78]
    3113             : #define SWIGTYPE_p_lldb__SBValueList swig_types[79]
    3114             : #define SWIGTYPE_p_lldb__SBVariablesOptions swig_types[80]
    3115             : #define SWIGTYPE_p_lldb__SBWatchpoint swig_types[81]
    3116             : #define SWIGTYPE_p_lldb_private__SharingPtrT_lldb_private__ValueObject_t swig_types[82]
    3117             : #define SWIGTYPE_p_long_double swig_types[83]
    3118             : #define SWIGTYPE_p_long_long swig_types[84]
    3119             : #define SWIGTYPE_p_p_void swig_types[85]
    3120             : #define SWIGTYPE_p_pthread_rwlock_t swig_types[86]
    3121             : #define SWIGTYPE_p_pthread_t swig_types[87]
    3122             : #define SWIGTYPE_p_short swig_types[88]
    3123             : #define SWIGTYPE_p_signed_char swig_types[89]
    3124             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ABI_t swig_types[90]
    3125             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Baton_t swig_types[91]
    3126             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Block_t swig_types[92]
    3127             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointLocation_t swig_types[93]
    3128             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointResolver_t swig_types[94]
    3129             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointSite_t swig_types[95]
    3130             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Breakpoint_t swig_types[96]
    3131             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__BroadcasterManager_t swig_types[97]
    3132             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Broadcaster_t swig_types[98]
    3133             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ClangASTImporter_t swig_types[99]
    3134             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__CommandObject_t swig_types[100]
    3135             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Communication_t swig_types[101]
    3136             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__CompileUnit_t swig_types[102]
    3137             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Connection_t swig_types[103]
    3138             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataBuffer_t swig_types[104]
    3139             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataExtractor_t swig_types[105]
    3140             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Debugger_t swig_types[106]
    3141             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Disassembler_t swig_types[107]
    3142             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__DynamicLoader_t swig_types[108]
    3143             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventDataStructuredData_t swig_types[109]
    3144             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventData_t swig_types[110]
    3145             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Event_t swig_types[111]
    3146             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExecutionContextRef_t swig_types[112]
    3147             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExpressionVariable_t swig_types[113]
    3148             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__File_t swig_types[114]
    3149             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__FuncUnwinders_t swig_types[115]
    3150             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__FunctionCaller_t swig_types[116]
    3151             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Function_t swig_types[117]
    3152             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOHandler_t swig_types[118]
    3153             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOObject_t swig_types[119]
    3154             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__IRExecutionUnit_t swig_types[120]
    3155             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t swig_types[121]
    3156             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Instruction_t swig_types[122]
    3157             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t swig_types[123]
    3158             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__JITLoader_t swig_types[124]
    3159             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__LanguageRuntime_t swig_types[125]
    3160             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__LineTable_t swig_types[126]
    3161             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Listener_t swig_types[127]
    3162             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryHistory_t swig_types[128]
    3163             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t swig_types[129]
    3164             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Module_t swig_types[130]
    3165             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[131]
    3166             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFile_t swig_types[132]
    3167             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueArch_t swig_types[133]
    3168             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueArgs_t swig_types[134]
    3169             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueArray_t swig_types[135]
    3170             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueBoolean_t swig_types[136]
    3171             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueDictionary_t swig_types[137]
    3172             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueFileSpecList_t swig_types[138]
    3173             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueFileSpec_t swig_types[139]
    3174             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueFormat_t swig_types[140]
    3175             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValuePathMappings_t swig_types[141]
    3176             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueProperties_t swig_types[142]
    3177             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueRegex_t swig_types[143]
    3178             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueSInt64_t swig_types[144]
    3179             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueString_t swig_types[145]
    3180             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueUInt64_t swig_types[146]
    3181             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueUUID_t swig_types[147]
    3182             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValue_t swig_types[148]
    3183             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Platform_t swig_types[149]
    3184             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t swig_types[150]
    3185             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t swig_types[151]
    3186             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Process_t swig_types[152]
    3187             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Property_t swig_types[153]
    3188             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t swig_types[154]
    3189             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Queue_t swig_types[155]
    3190             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__REPL_t swig_types[156]
    3191             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t swig_types[157]
    3192             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterContext_t swig_types[158]
    3193             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegularExpression_t swig_types[159]
    3194             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptInterpreter_t swig_types[160]
    3195             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t swig_types[161]
    3196             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t swig_types[162]
    3197             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SearchFilter_t swig_types[163]
    3198             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SectionLoadList_t swig_types[164]
    3199             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Section_t swig_types[165]
    3200             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Settings_t swig_types[166]
    3201             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameList_t swig_types[167]
    3202             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrame_t swig_types[168]
    3203             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StopInfo_t swig_types[169]
    3204             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StoppointLocation_t swig_types[170]
    3205             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StreamFile_t swig_types[171]
    3206             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Stream_t swig_types[172]
    3207             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StringSummaryFormat_t swig_types[173]
    3208             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t swig_types[174]
    3209             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t swig_types[175]
    3210             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolFileType_t swig_types[176]
    3211             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolFile_t swig_types[177]
    3212             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t swig_types[178]
    3213             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildren_t swig_types[179]
    3214             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SystemRuntime_t swig_types[180]
    3215             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TargetProperties_t swig_types[181]
    3216             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Target_t swig_types[182]
    3217             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadCollection_t swig_types[183]
    3218             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t swig_types[184]
    3219             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlan_t swig_types[185]
    3220             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Thread_t swig_types[186]
    3221             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TraceOptions_t swig_types[187]
    3222             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t swig_types[188]
    3223             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t swig_types[189]
    3224             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFilterImpl_t swig_types[190]
    3225             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFormatImpl_t swig_types[191]
    3226             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeImpl_t swig_types[192]
    3227             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t swig_types[193]
    3228             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t swig_types[194]
    3229             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t swig_types[195]
    3230             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t swig_types[196]
    3231             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSystem_t swig_types[197]
    3232             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeValidatorImpl_t swig_types[198]
    3233             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Type_t swig_types[199]
    3234             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnixSignals_t swig_types[200]
    3235             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindAssembly_t swig_types[201]
    3236             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindPlan_t swig_types[202]
    3237             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__UserExpression_t swig_types[203]
    3238             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__UtilityFunction_t swig_types[204]
    3239             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueList_t swig_types[205]
    3240             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObjectList_t swig_types[206]
    3241             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Value_t swig_types[207]
    3242             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__VariableList_t swig_types[208]
    3243             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Variable_t swig_types[209]
    3244             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Watchpoint_t swig_types[210]
    3245             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__ClangASTContext_t swig_types[211]
    3246             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__ClangModulesDeclVendor_t swig_types[212]
    3247             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__ClangPersistentVariables_t swig_types[213]
    3248             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t swig_types[214]
    3249             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicLoader_t swig_types[215]
    3250             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__GoASTContext_t swig_types[216]
    3251             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__JITLoaderList_t swig_types[217]
    3252             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t swig_types[218]
    3253             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__OperatingSystem_t swig_types[219]
    3254             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__ScriptInterpreter_t swig_types[220]
    3255             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__SectionList_t swig_types[221]
    3256             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__SourceManager_t swig_types[222]
    3257             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__StackFrame_t swig_types[223]
    3258             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__StructuredDataImpl_t swig_types[224]
    3259             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__SymbolVendor_t swig_types[225]
    3260             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__SystemRuntime_t swig_types[226]
    3261             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__BreakpointLocation_t swig_types[227]
    3262             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__BreakpointSite_t swig_types[228]
    3263             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Breakpoint_t swig_types[229]
    3264             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__BroadcasterManager_t swig_types[230]
    3265             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Debugger_t swig_types[231]
    3266             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Listener_t swig_types[232]
    3267             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Module_t swig_types[233]
    3268             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[234]
    3269             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__ObjectFile_t swig_types[235]
    3270             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__OptionValue_t swig_types[236]
    3271             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Process_t swig_types[237]
    3272             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Queue_t swig_types[238]
    3273             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Section_t swig_types[239]
    3274             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__StackFrame_t swig_types[240]
    3275             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Stream_t swig_types[241]
    3276             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t swig_types[242]
    3277             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__SymbolFileType_t swig_types[243]
    3278             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Target_t swig_types[244]
    3279             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Thread_t swig_types[245]
    3280             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Type_t swig_types[246]
    3281             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__UnixSignals_t swig_types[247]
    3282             : #define SWIGTYPE_p_unsigned_char swig_types[248]
    3283             : #define SWIGTYPE_p_unsigned_int swig_types[249]
    3284             : #define SWIGTYPE_p_unsigned_long_long swig_types[250]
    3285             : #define SWIGTYPE_p_unsigned_short swig_types[251]
    3286             : #define SWIGTYPE_p_void swig_types[252]
    3287             : static swig_type_info *swig_types[254];
    3288             : static swig_module_info swig_module = {swig_types, 253, 0, 0, 0, 0};
    3289             : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
    3290             : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
    3291             : 
    3292             : /* -------- TYPES TABLE (END) -------- */
    3293             : 
    3294             : #if (PY_VERSION_HEX <= 0x02000000)
    3295             : # if !defined(SWIG_PYTHON_CLASSIC)
    3296             : #  error "This python version requires swig to be run with the '-classic' option"
    3297             : # endif
    3298             : #endif
    3299             : 
    3300             : /*-----------------------------------------------
    3301             :               @(target):= _lldb.so
    3302             :   ------------------------------------------------*/
    3303             : #if PY_VERSION_HEX >= 0x03000000
    3304             : #  define SWIG_init    PyInit__lldb
    3305             : 
    3306             : #else
    3307             : #  define SWIG_init    init_lldb
    3308             : 
    3309             : #endif
    3310             : #define SWIG_name    "_lldb"
    3311             : 
    3312             : #define SWIGVERSION 0x030012 
    3313             : #define SWIG_VERSION SWIGVERSION
    3314             : 
    3315             : 
    3316             : #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
    3317             : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
    3318             : 
    3319             : 
    3320             : #include <stdexcept>
    3321             : 
    3322             : 
    3323             : namespace swig {
    3324             :   class SwigPtr_PyObject {
    3325             :   protected:
    3326             :     PyObject *_obj;
    3327             : 
    3328             :   public:
    3329             :     SwigPtr_PyObject() :_obj(0)
    3330             :     {
    3331             :     }
    3332             : 
    3333             :     SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    3334             :     {
    3335             :       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3336             :       Py_XINCREF(_obj);      
    3337             :       SWIG_PYTHON_THREAD_END_BLOCK;
    3338             :     }
    3339             :     
    3340             :     SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    3341             :     {
    3342             :       if (initial_ref) {
    3343             :         SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3344             :         Py_XINCREF(_obj);
    3345             :         SWIG_PYTHON_THREAD_END_BLOCK;
    3346             :       }
    3347             :     }
    3348             :     
    3349             :     SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    3350             :     {
    3351             :       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3352             :       Py_XINCREF(item._obj);
    3353             :       Py_XDECREF(_obj);
    3354             :       _obj = item._obj;
    3355             :       SWIG_PYTHON_THREAD_END_BLOCK;
    3356             :       return *this;      
    3357             :     }
    3358             :     
    3359             :     ~SwigPtr_PyObject() 
    3360             :     {
    3361             :       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3362             :       Py_XDECREF(_obj);
    3363             :       SWIG_PYTHON_THREAD_END_BLOCK;
    3364             :     }
    3365             :     
    3366             :     operator PyObject *() const
    3367             :     {
    3368             :       return _obj;
    3369             :     }
    3370             : 
    3371             :     PyObject *operator->() const
    3372             :     {
    3373             :       return _obj;
    3374             :     }
    3375             :   };
    3376             : }
    3377             : 
    3378             : 
    3379             : namespace swig {
    3380             :   struct SwigVar_PyObject : SwigPtr_PyObject {
    3381             :     SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    3382             :     
    3383             :     SwigVar_PyObject & operator = (PyObject* obj)
    3384             :     {
    3385             :       Py_XDECREF(_obj);
    3386             :       _obj = obj;
    3387             :       return *this;      
    3388             :     }
    3389             :   };
    3390             : }
    3391             : 
    3392             : 
    3393             : #include <algorithm>
    3394             : #include <string>
    3395             : 
    3396             : 
    3397             : #include "lldb/lldb-public.h"
    3398             : #include "lldb/API/SBAddress.h"
    3399             : #include "lldb/API/SBAttachInfo.h"
    3400             : #include "lldb/API/SBBlock.h"
    3401             : #include "lldb/API/SBBreakpoint.h"
    3402             : #include "lldb/API/SBBreakpointLocation.h"
    3403             : #include "lldb/API/SBBroadcaster.h"
    3404             : #include "lldb/API/SBCommandInterpreter.h"
    3405             : #include "lldb/API/SBCommandReturnObject.h"
    3406             : #include "lldb/API/SBCommunication.h"
    3407             : #include "lldb/API/SBCompileUnit.h"
    3408             : #include "lldb/API/SBData.h"
    3409             : #include "lldb/API/SBDebugger.h"
    3410             : #include "lldb/API/SBDeclaration.h"
    3411             : #include "lldb/API/SBError.h"
    3412             : #include "lldb/API/SBEvent.h"
    3413             : #include "lldb/API/SBExecutionContext.h"
    3414             : #include "lldb/API/SBExpressionOptions.h"
    3415             : #include "lldb/API/SBFileSpec.h"
    3416             : #include "lldb/API/SBFileSpecList.h"
    3417             : #include "lldb/API/SBFrame.h"
    3418             : #include "lldb/API/SBFunction.h"
    3419             : #include "lldb/API/SBHostOS.h"
    3420             : #include "lldb/API/SBInstruction.h"
    3421             : #include "lldb/API/SBInstructionList.h"
    3422             : #include "lldb/API/SBLanguageRuntime.h"
    3423             : #include "lldb/API/SBLaunchInfo.h"
    3424             : #include "lldb/API/SBLineEntry.h"
    3425             : #include "lldb/API/SBListener.h"
    3426             : #include "lldb/API/SBMemoryRegionInfo.h"
    3427             : #include "lldb/API/SBMemoryRegionInfoList.h"
    3428             : #include "lldb/API/SBModule.h"
    3429             : #include "lldb/API/SBModuleSpec.h"
    3430             : #include "lldb/API/SBPlatform.h"
    3431             : #include "lldb/API/SBProcess.h"
    3432             : #include "lldb/API/SBProcessInfo.h"
    3433             : #include "lldb/API/SBQueue.h"
    3434             : #include "lldb/API/SBQueueItem.h"
    3435             : #include "lldb/API/SBSection.h"
    3436             : #include "lldb/API/SBSourceManager.h"
    3437             : #include "lldb/API/SBStream.h"
    3438             : #include "lldb/API/SBStringList.h"
    3439             : #include "lldb/API/SBStructuredData.h"
    3440             : #include "lldb/API/SBSymbol.h"
    3441             : #include "lldb/API/SBSymbolContext.h"
    3442             : #include "lldb/API/SBSymbolContextList.h"
    3443             : #include "lldb/API/SBTarget.h"
    3444             : #include "lldb/API/SBThread.h"
    3445             : #include "lldb/API/SBThreadCollection.h"
    3446             : #include "lldb/API/SBThreadPlan.h"
    3447             : #include "lldb/API/SBTrace.h"
    3448             : #include "lldb/API/SBTraceOptions.h"
    3449             : #include "lldb/API/SBType.h"
    3450             : #include "lldb/API/SBTypeCategory.h"
    3451             : #include "lldb/API/SBTypeEnumMember.h"
    3452             : #include "lldb/API/SBTypeFilter.h"
    3453             : #include "lldb/API/SBTypeFormat.h"
    3454             : #include "lldb/API/SBTypeNameSpecifier.h"
    3455             : #include "lldb/API/SBTypeSummary.h"
    3456             : #include "lldb/API/SBTypeSynthetic.h"
    3457             : #include "lldb/API/SBValue.h"
    3458             : #include "lldb/API/SBValueList.h"
    3459             : #include "lldb/API/SBVariablesOptions.h"
    3460             : #include "lldb/API/SBWatchpoint.h"
    3461             : #include "lldb/API/SBUnixSignals.h"
    3462             : 
    3463             : #include "../source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h"
    3464             : 
    3465             : #include "../scripts/Python/python-swigsafecast.swig"
    3466             : 
    3467             : 
    3468             : #include <stdint.h>               // Use the C99 official header
    3469             : 
    3470             : 
    3471             : SWIGINTERNINLINE PyObject*
    3472             :   SWIG_From_int  (int value)
    3473             : {
    3474      409886 :   return PyInt_FromLong((long) value);
    3475             : }
    3476             : 
    3477             : 
    3478             : SWIGINTERNINLINE PyObject*
    3479             :   SWIG_From_unsigned_SS_int  (unsigned int value)
    3480             : {
    3481       16081 :   return PyInt_FromSize_t((size_t) value);
    3482             : }
    3483             : 
    3484             : 
    3485             : #include <limits.h>
    3486             : #if !defined(SWIG_NO_LLONG_MAX)
    3487             : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
    3488             : #   define LLONG_MAX __LONG_LONG_MAX__
    3489             : #   define LLONG_MIN (-LLONG_MAX - 1LL)
    3490             : #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
    3491             : # endif
    3492             : #endif
    3493             : 
    3494             : 
    3495             : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
    3496             : #  define SWIG_LONG_LONG_AVAILABLE
    3497             : #endif
    3498             : 
    3499             : 
    3500             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3501             : SWIGINTERNINLINE PyObject* 
    3502       89738 : SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
    3503             : {
    3504       92202 :   return (value > LONG_MAX) ?
    3505       89738 :     PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
    3506             : }
    3507             : #endif
    3508             : 
    3509             : 
    3510             : SWIGINTERN swig_type_info*
    3511         249 : SWIG_pchar_descriptor(void)
    3512             : {
    3513             :   static int init = 0;
    3514             :   static swig_type_info* info = 0;
    3515         249 :   if (!init) {
    3516          16 :     info = SWIG_TypeQuery("_p_char");
    3517          16 :     init = 1;
    3518             :   }
    3519         249 :   return info;
    3520             : }
    3521             : 
    3522             : 
    3523             : SWIGINTERNINLINE PyObject *
    3524       16052 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
    3525             : {
    3526       16052 :   if (carray) {
    3527       15465 :     if (size > INT_MAX) {
    3528           0 :       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    3529           0 :       return pchar_descriptor ? 
    3530             :         SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    3531             :     } else {
    3532             : #if PY_VERSION_HEX >= 0x03000000
    3533             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3534             :       return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
    3535             : #else
    3536             : #if PY_VERSION_HEX >= 0x03010000
    3537             :       return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
    3538             : #else
    3539             :       return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
    3540             : #endif
    3541             : #endif
    3542             : #else
    3543       15465 :       return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
    3544             : #endif
    3545             :     }
    3546             :   } else {
    3547         587 :     return SWIG_Py_Void();
    3548             :   }
    3549             : }
    3550             : 
    3551             : 
    3552             : SWIGINTERNINLINE PyObject * 
    3553       14204 : SWIG_FromCharPtr(const char *cptr)
    3554             : { 
    3555       16052 :   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
    3556             : }
    3557             : 
    3558             : 
    3559             : SWIGINTERNINLINE PyObject*
    3560             :   SWIG_From_bool  (bool value)
    3561             : {
    3562       22154 :   return PyBool_FromLong(value ? 1 : 0);
    3563             : }
    3564             : 
    3565             : 
    3566             : SWIGINTERN int
    3567           2 : SWIG_AsVal_double (PyObject *obj, double *val)
    3568             : {
    3569           2 :   int res = SWIG_TypeError;
    3570           2 :   if (PyFloat_Check(obj)) {
    3571           3 :     if (val) *val = PyFloat_AsDouble(obj);
    3572             :     return SWIG_OK;
    3573             : #if PY_VERSION_HEX < 0x03000000
    3574           0 :   } else if (PyInt_Check(obj)) {
    3575           0 :     if (val) *val = (double) PyInt_AsLong(obj);
    3576             :     return SWIG_OK;
    3577             : #endif
    3578           0 :   } else if (PyLong_Check(obj)) {
    3579           0 :     double v = PyLong_AsDouble(obj);
    3580           0 :     if (!PyErr_Occurred()) {
    3581           0 :       if (val) *val = v;
    3582             :       return SWIG_OK;
    3583             :     } else {
    3584           0 :       PyErr_Clear();
    3585             :     }
    3586             :   }
    3587             : #ifdef SWIG_PYTHON_CAST_MODE
    3588             :   {
    3589             :     int dispatch = 0;
    3590             :     double d = PyFloat_AsDouble(obj);
    3591             :     if (!PyErr_Occurred()) {
    3592             :       if (val) *val = d;
    3593             :       return SWIG_AddCast(SWIG_OK);
    3594             :     } else {
    3595             :       PyErr_Clear();
    3596             :     }
    3597             :     if (!dispatch) {
    3598             :       long v = PyLong_AsLong(obj);
    3599             :       if (!PyErr_Occurred()) {
    3600             :         if (val) *val = v;
    3601             :         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
    3602             :       } else {
    3603             :         PyErr_Clear();
    3604             :       }
    3605             :     }
    3606             :   }
    3607             : #endif
    3608             :   return res;
    3609             : }
    3610             : 
    3611             : 
    3612             : #include <float.h>
    3613             : 
    3614             : 
    3615             : #include <math.h>
    3616             : 
    3617             : 
    3618             : SWIGINTERNINLINE int
    3619             : SWIG_CanCastAsInteger(double *d, double min, double max) {
    3620             :   double x = *d;
    3621             :   if ((min <= x && x <= max)) {
    3622             :    double fx = floor(x);
    3623             :    double cx = ceil(x);
    3624             :    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
    3625             :    if ((errno == EDOM) || (errno == ERANGE)) {
    3626             :      errno = 0;
    3627             :    } else {
    3628             :      double summ, reps, diff;
    3629             :      if (rd < x) {
    3630             :        diff = x - rd;
    3631             :      } else if (rd > x) {
    3632             :        diff = rd - x;
    3633             :      } else {
    3634             :        return 1;
    3635             :      }
    3636             :      summ = rd + x;
    3637             :      reps = diff/summ;
    3638             :      if (reps < 8*DBL_EPSILON) {
    3639             :        *d = rd;
    3640             :        return 1;
    3641             :      }
    3642             :    }
    3643             :   }
    3644             :   return 0;
    3645             : }
    3646             : 
    3647             : 
    3648             : SWIGINTERN int
    3649       25224 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
    3650             : {
    3651             : #if PY_VERSION_HEX < 0x03000000
    3652       25224 :   if (PyInt_Check(obj)) {
    3653       25224 :     long v = PyInt_AsLong(obj);
    3654       25224 :     if (v >= 0) {
    3655       25224 :       if (val) *val = v;
    3656             :       return SWIG_OK;
    3657             :     } else {
    3658             :       return SWIG_OverflowError;
    3659             :     }
    3660             :   } else
    3661             : #endif
    3662           0 :   if (PyLong_Check(obj)) {
    3663           0 :     unsigned long v = PyLong_AsUnsignedLong(obj);
    3664           0 :     if (!PyErr_Occurred()) {
    3665           0 :       if (val) *val = v;
    3666             :       return SWIG_OK;
    3667             :     } else {
    3668           0 :       PyErr_Clear();
    3669           0 :       return SWIG_OverflowError;
    3670             :     }
    3671             :   }
    3672             : #ifdef SWIG_PYTHON_CAST_MODE
    3673             :   {
    3674             :     int dispatch = 0;
    3675             :     unsigned long v = PyLong_AsUnsignedLong(obj);
    3676             :     if (!PyErr_Occurred()) {
    3677             :       if (val) *val = v;
    3678             :       return SWIG_AddCast(SWIG_OK);
    3679             :     } else {
    3680             :       PyErr_Clear();
    3681             :     }
    3682             :     if (!dispatch) {
    3683             :       double d;
    3684             :       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
    3685             :       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
    3686             :         if (val) *val = (unsigned long)(d);
    3687             :         return res;
    3688             :       }
    3689             :     }
    3690             :   }
    3691             : #endif
    3692             :   return SWIG_TypeError;
    3693             : }
    3694             : 
    3695             : 
    3696             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3697             : SWIGINTERN int
    3698         215 : SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
    3699             : {
    3700         215 :   int res = SWIG_TypeError;
    3701         215 :   if (PyLong_Check(obj)) {
    3702          15 :     unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    3703          15 :     if (!PyErr_Occurred()) {
    3704          15 :       if (val) *val = v;
    3705             :       return SWIG_OK;
    3706             :     } else {
    3707           0 :       PyErr_Clear();
    3708           0 :       res = SWIG_OverflowError;
    3709             :     }
    3710             :   } else {
    3711             :     unsigned long v;
    3712         200 :     res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    3713         200 :     if (SWIG_IsOK(res)) {
    3714         200 :       if (val) *val = v;
    3715         200 :       return res;
    3716             :     }
    3717             :   }
    3718             : #ifdef SWIG_PYTHON_CAST_MODE
    3719             :   {
    3720             :     const double mant_max = 1LL << DBL_MANT_DIG;
    3721             :     double d;
    3722             :     res = SWIG_AsVal_double (obj,&d);
    3723             :     if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
    3724             :       return SWIG_OverflowError;
    3725             :     if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
    3726             :       if (val) *val = (unsigned long long)(d);
    3727             :       return SWIG_AddCast(res);
    3728             :     }
    3729             :     res = SWIG_TypeError;
    3730             :   }
    3731             : #endif
    3732             :   return res;
    3733             : }
    3734             : #endif
    3735             : 
    3736             : 
    3737             : SWIGINTERN int
    3738             : SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
    3739             : {
    3740             :   unsigned long v;
    3741        2112 :   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
    3742        2112 :   if (SWIG_IsOK(res)) {
    3743        2112 :     if ((v > UINT_MAX)) {
    3744             :       return SWIG_OverflowError;
    3745             :     } else {
    3746        1797 :       if (val) *val = static_cast< unsigned int >(v);
    3747             :     }
    3748             :   }  
    3749             :   return res;
    3750             : }
    3751             : 
    3752           0 : SWIGINTERN PyObject *lldb_SBAddress___str__(lldb::SBAddress *self){
    3753           0 :                 lldb::SBStream description;
    3754           0 :                 self->GetDescription (description);
    3755           0 :                 const char *desc = description.GetData();
    3756           0 :                 size_t desc_len = description.GetSize();
    3757           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    3758           0 :                     --desc_len;
    3759           0 :                 if (desc_len > 0)
    3760           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    3761             :                 else
    3762           0 :                     return lldb_private::PythonString("").release();
    3763             :         }
    3764             : 
    3765             : SWIGINTERN int
    3766       12194 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
    3767             : {
    3768             : #if PY_VERSION_HEX>=0x03000000
    3769             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3770             :   if (PyBytes_Check(obj))
    3771             : #else
    3772             :   if (PyUnicode_Check(obj))
    3773             : #endif
    3774             : #else  
    3775       12194 :   if (PyString_Check(obj))
    3776             : #endif
    3777             :   {
    3778             :     char *cstr; Py_ssize_t len;
    3779             : #if PY_VERSION_HEX>=0x03000000
    3780             : #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3781             :     if (!alloc && cptr) {
    3782             :         /* We can't allow converting without allocation, since the internal
    3783             :            representation of string in Python 3 is UCS-2/UCS-4 but we require
    3784             :            a UTF-8 representation.
    3785             :            TODO(bhy) More detailed explanation */
    3786             :         return SWIG_RuntimeError;
    3787             :     }
    3788             :     obj = PyUnicode_AsUTF8String(obj);
    3789             :     if(alloc) *alloc = SWIG_NEWOBJ;
    3790             : #endif
    3791             :     PyBytes_AsStringAndSize(obj, &cstr, &len);
    3792             : #else
    3793       11945 :     PyString_AsStringAndSize(obj, &cstr, &len);
    3794             : #endif
    3795       11945 :     if (cptr) {
    3796        6395 :       if (alloc) {
    3797             :         /* 
    3798             :            In python the user should not be able to modify the inner
    3799             :            string representation. To warranty that, if you define
    3800             :            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
    3801             :            buffer is always returned.
    3802             : 
    3803             :            The default behavior is just to return the pointer value,
    3804             :            so, be careful.
    3805             :         */ 
    3806             : #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
    3807             :         if (*alloc != SWIG_OLDOBJ) 
    3808             : #else
    3809        6395 :         if (*alloc == SWIG_NEWOBJ) 
    3810             : #endif
    3811             :         {
    3812           0 :           *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
    3813           0 :           *alloc = SWIG_NEWOBJ;
    3814             :         } else {
    3815        6395 :           *cptr = cstr;
    3816        6395 :           *alloc = SWIG_OLDOBJ;
    3817             :         }
    3818             :       } else {
    3819             : #if PY_VERSION_HEX>=0x03000000
    3820             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3821             :         *cptr = PyBytes_AsString(obj);
    3822             : #else
    3823             :         assert(0); /* Should never reach here with Unicode strings in Python 3 */
    3824             : #endif
    3825             : #else
    3826           0 :         *cptr = SWIG_Python_str_AsChar(obj);
    3827             : #endif
    3828             :       }
    3829             :     }
    3830       11945 :     if (psize) *psize = len + 1;
    3831             : #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3832             :     Py_XDECREF(obj);
    3833             : #endif
    3834             :     return SWIG_OK;
    3835             :   } else {
    3836             : #if defined(SWIG_PYTHON_2_UNICODE)
    3837             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3838             : #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
    3839             : #endif
    3840             : #if PY_VERSION_HEX<0x03000000
    3841             :     if (PyUnicode_Check(obj)) {
    3842             :       char *cstr; Py_ssize_t len;
    3843             :       if (!alloc && cptr) {
    3844             :         return SWIG_RuntimeError;
    3845             :       }
    3846             :       obj = PyUnicode_AsUTF8String(obj);
    3847             :       if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
    3848             :         if (cptr) {
    3849             :           if (alloc) *alloc = SWIG_NEWOBJ;
    3850             :           *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
    3851             :         }
    3852             :         if (psize) *psize = len + 1;
    3853             : 
    3854             :         Py_XDECREF(obj);
    3855             :         return SWIG_OK;
    3856             :       } else {
    3857             :         Py_XDECREF(obj);
    3858             :       }
    3859             :     }
    3860             : #endif
    3861             : #endif
    3862             : 
    3863         249 :     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    3864         249 :     if (pchar_descriptor) {
    3865         249 :       void* vptr = 0;
    3866         249 :       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
    3867         249 :         if (cptr) *cptr = (char *) vptr;
    3868         249 :         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
    3869         249 :         if (alloc) *alloc = SWIG_OLDOBJ;
    3870         249 :         return SWIG_OK;
    3871             :       }
    3872             :     }
    3873             :   }
    3874             :   return SWIG_TypeError;
    3875             : }
    3876             : 
    3877             : 
    3878             : 
    3879             : 
    3880             : 
    3881             : SWIGINTERN int
    3882         382 : SWIG_AsVal_long (PyObject *obj, long* val)
    3883             : {
    3884             : #if PY_VERSION_HEX < 0x03000000
    3885         382 :   if (PyInt_Check(obj)) {
    3886         382 :     if (val) *val = PyInt_AsLong(obj);
    3887             :     return SWIG_OK;
    3888             :   } else
    3889             : #endif
    3890           0 :   if (PyLong_Check(obj)) {
    3891           0 :     long v = PyLong_AsLong(obj);
    3892           0 :     if (!PyErr_Occurred()) {
    3893           0 :       if (val) *val = v;
    3894             :       return SWIG_OK;
    3895             :     } else {
    3896           0 :       PyErr_Clear();
    3897           0 :       return SWIG_OverflowError;
    3898             :     }
    3899             :   }
    3900             : #ifdef SWIG_PYTHON_CAST_MODE
    3901             :   {
    3902             :     int dispatch = 0;
    3903             :     long v = PyInt_AsLong(obj);
    3904             :     if (!PyErr_Occurred()) {
    3905             :       if (val) *val = v;
    3906             :       return SWIG_AddCast(SWIG_OK);
    3907             :     } else {
    3908             :       PyErr_Clear();
    3909             :     }
    3910             :     if (!dispatch) {
    3911             :       double d;
    3912             :       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
    3913             :       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
    3914             :         if (val) *val = (long)(d);
    3915             :         return res;
    3916             :       }
    3917             :     }
    3918             :   }
    3919             : #endif
    3920             :   return SWIG_TypeError;
    3921             : }
    3922             : 
    3923             : 
    3924             : SWIGINTERN int
    3925             : SWIG_AsVal_bool (PyObject *obj, bool *val)
    3926             : {
    3927             :   int r;
    3928       10141 :   if (!PyBool_Check(obj))
    3929             :     return SWIG_ERROR;
    3930       10141 :   r = PyObject_IsTrue(obj);
    3931       10141 :   if (r == -1)
    3932             :     return SWIG_ERROR;
    3933        5869 :   if (val) *val = r ? true : false;
    3934             :   return SWIG_OK;
    3935             : }
    3936             : 
    3937             : 
    3938             : SWIGINTERN int
    3939             : SWIG_AsVal_int (PyObject * obj, int *val)
    3940             : {
    3941             :   long v;
    3942         378 :   int res = SWIG_AsVal_long (obj, &v);
    3943         378 :   if (SWIG_IsOK(res)) {
    3944         378 :     if ((v < INT_MIN || v > INT_MAX)) {
    3945             :       return SWIG_OverflowError;
    3946             :     } else {
    3947         323 :       if (val) *val = static_cast< int >(v);
    3948             :     }
    3949             :   }  
    3950             :   return res;
    3951             : }
    3952             : 
    3953           0 : SWIGINTERN PyObject *lldb_SBBlock___str__(lldb::SBBlock *self){
    3954           0 :                 lldb::SBStream description;
    3955           0 :                 self->GetDescription (description);
    3956           0 :                 const char *desc = description.GetData();
    3957           0 :                 size_t desc_len = description.GetSize();
    3958           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    3959           0 :                     --desc_len;
    3960           0 :                 if (desc_len > 0)
    3961           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    3962             :                 else
    3963           0 :                     return lldb_private::PythonString("").release();
    3964             :         }
    3965             : 
    3966             :   #define SWIG_From_long   PyInt_FromLong 
    3967             : 
    3968             : 
    3969             : SWIGINTERNINLINE PyObject* 
    3970         632 : SWIG_From_unsigned_SS_long  (unsigned long value)
    3971             : {
    3972         632 :   return (value > LONG_MAX) ?
    3973         632 :     PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
    3974             : }
    3975             : 
    3976             : 
    3977             : SWIGINTERNINLINE PyObject *
    3978             : SWIG_From_size_t  (size_t value)
    3979             : {    
    3980             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3981             :   if (sizeof(size_t) <= sizeof(unsigned long)) {
    3982             : #endif
    3983         632 :     return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
    3984             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3985             :   } else {
    3986             :     /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    3987             :     return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
    3988             :   }
    3989             : #endif
    3990             : }
    3991             : 
    3992           8 : SWIGINTERN PyObject *lldb_SBBreakpoint___str__(lldb::SBBreakpoint *self){
    3993          16 :                 lldb::SBStream description;
    3994           8 :                 self->GetDescription (description);
    3995           8 :                 const char *desc = description.GetData();
    3996           8 :                 size_t desc_len = description.GetSize();
    3997           8 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    3998           0 :                     --desc_len;
    3999           8 :                 if (desc_len > 0)
    4000          16 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4001             :                 else
    4002           0 :                     return lldb_private::PythonString("").release();
    4003             :         }
    4004             : 
    4005             : SWIGINTERNINLINE int
    4006             : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
    4007             : {
    4008       22904 :   int res = SWIG_TypeError;
    4009             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4010             :   if (sizeof(size_t) <= sizeof(unsigned long)) {
    4011             : #endif
    4012             :     unsigned long v;
    4013       22904 :     res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    4014       22904 :     if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
    4015             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4016             :   } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    4017             :     unsigned long long v;
    4018             :     res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    4019             :     if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
    4020             :   }
    4021             : #endif
    4022             :   return res;
    4023             : }
    4024             : 
    4025           0 : SWIGINTERN PyObject *lldb_SBBreakpointLocation___str__(lldb::SBBreakpointLocation *self){
    4026           0 :                 lldb::SBStream description;
    4027           0 :                 self->GetDescription (description, lldb::eDescriptionLevelFull);
    4028           0 :                 const char *desc = description.GetData();
    4029           0 :                 size_t desc_len = description.GetSize();
    4030           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4031           0 :                     --desc_len;
    4032           0 :                 if (desc_len > 0)
    4033           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4034             :                 else
    4035           0 :                     return lldb_private::PythonString("").release();
    4036             :         }
    4037             : 
    4038             : SWIGINTERN int
    4039           0 : SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
    4040             : { 
    4041           0 :   char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
    4042           0 :   int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
    4043           0 :   if (SWIG_IsOK(res)) {
    4044             :     /* special case of single char conversion when we don't need space for NUL */
    4045           0 :     if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    4046           0 :     if (csize <= size) {
    4047           0 :       if (val) {
    4048           0 :         if (csize) memcpy(val, cptr, csize*sizeof(char));
    4049           0 :         if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
    4050             :       }
    4051           0 :       if (alloc == SWIG_NEWOBJ) {
    4052           0 :         delete[] cptr;
    4053           0 :         res = SWIG_DelNewMask(res);
    4054             :       }      
    4055             :       return res;
    4056             :     }
    4057           0 :     if (alloc == SWIG_NEWOBJ) delete[] cptr;
    4058             :   }
    4059             :   return SWIG_TypeError;
    4060             : }
    4061             : 
    4062             : 
    4063             : SWIGINTERN int
    4064           0 : SWIG_AsVal_char (PyObject * obj, char *val)
    4065             : {    
    4066           0 :   int res = SWIG_AsCharArray(obj, val, 1);
    4067           0 :   if (!SWIG_IsOK(res)) {
    4068             :     long v;
    4069           0 :     res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    4070           0 :     if (SWIG_IsOK(res)) {
    4071           0 :       if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
    4072           0 :         if (val) *val = static_cast< char >(v);
    4073             :       } else {
    4074             :         res = SWIG_OverflowError;
    4075             :       }
    4076             :     }
    4077             :   }
    4078           0 :   return res;
    4079             : }
    4080             : 
    4081             : SWIGINTERN void lldb_SBCommandReturnObject_SetImmediateOutputFile(lldb::SBCommandReturnObject *self,FILE *fh){
    4082           2 :             self->SetImmediateOutputFile(fh, true);
    4083             :         }
    4084             : SWIGINTERN void lldb_SBCommandReturnObject_SetImmediateErrorFile(lldb::SBCommandReturnObject *self,FILE *fh){
    4085           0 :             self->SetImmediateErrorFile(fh, true);
    4086             :         }
    4087             : SWIGINTERN void lldb_SBCommandReturnObject_Print(lldb::SBCommandReturnObject *self,char const *str){
    4088           0 :             self->Printf("%s", str);
    4089             :         }
    4090           2 : SWIGINTERN PyObject *lldb_SBCommandReturnObject___str__(lldb::SBCommandReturnObject *self){
    4091           4 :                 lldb::SBStream description;
    4092           2 :                 self->GetDescription (description);
    4093           2 :                 const char *desc = description.GetData();
    4094           2 :                 size_t desc_len = description.GetSize();
    4095           2 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4096           2 :                     --desc_len;
    4097           2 :                 if (desc_len > 0)
    4098           4 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4099             :                 else
    4100           0 :                     return lldb_private::PythonString("").release();
    4101             :         }
    4102             : SWIGINTERN void lldb_SBCommandReturnObject_write(lldb::SBCommandReturnObject *self,char const *str){
    4103          38 :             if (str)
    4104          38 :                 self->Printf("%s",str);
    4105             :         }
    4106             : SWIGINTERN void lldb_SBCommandReturnObject_flush(lldb::SBCommandReturnObject *self){}
    4107           6 : SWIGINTERN PyObject *lldb_SBCompileUnit___str__(lldb::SBCompileUnit *self){
    4108          12 :                 lldb::SBStream description;
    4109           6 :                 self->GetDescription (description);
    4110           6 :                 const char *desc = description.GetData();
    4111           6 :                 size_t desc_len = description.GetSize();
    4112           6 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4113           6 :                     --desc_len;
    4114           6 :                 if (desc_len > 0)
    4115          12 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4116             :                 else
    4117           0 :                     return lldb_private::PythonString("").release();
    4118             :         }
    4119             : 
    4120             : SWIGINTERNINLINE PyObject *
    4121             : SWIG_From_unsigned_SS_char  (unsigned char value)
    4122             : {    
    4123           0 :   return SWIG_From_unsigned_SS_long  (value);
    4124             : }
    4125             : 
    4126             : 
    4127             : SWIGINTERN int
    4128             : SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
    4129             : {
    4130             :   unsigned long v;
    4131           8 :   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
    4132           8 :   if (SWIG_IsOK(res)) {
    4133           8 :     if ((v > UCHAR_MAX)) {
    4134             :       return SWIG_OverflowError;
    4135             :     } else {
    4136           8 :       if (val) *val = static_cast< unsigned char >(v);
    4137             :     }
    4138             :   }  
    4139             :   return res;
    4140             : }
    4141             : 
    4142             : 
    4143             :   #define SWIG_From_double   PyFloat_FromDouble 
    4144             : 
    4145             : 
    4146             : SWIGINTERNINLINE PyObject *
    4147             : SWIG_From_float  (float value)
    4148             : {    
    4149           0 :   return SWIG_From_double  (value);
    4150             : }
    4151             : 
    4152             : 
    4153             : SWIGINTERNINLINE PyObject *
    4154             : SWIG_From_unsigned_SS_short  (unsigned short value)
    4155             : {    
    4156           0 :   return SWIG_From_unsigned_SS_long  (value);
    4157             : }
    4158             : 
    4159             : 
    4160             : SWIGINTERNINLINE PyObject *
    4161             : SWIG_From_signed_SS_char  (signed char value)
    4162             : {    
    4163           0 :   return SWIG_From_long  (value);
    4164             : }
    4165             : 
    4166             : 
    4167             : SWIGINTERNINLINE PyObject *
    4168             : SWIG_From_short  (short value)
    4169             : {    
    4170           0 :   return SWIG_From_long  (value);
    4171             : }
    4172             : 
    4173             : 
    4174             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4175             : SWIGINTERNINLINE PyObject* 
    4176             : SWIG_From_long_SS_long  (long long value)
    4177             : {
    4178             :   return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    4179           3 :     PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
    4180             : }
    4181             : #endif
    4182             : 
    4183           0 : SWIGINTERN PyObject *lldb_SBData___str__(lldb::SBData *self){
    4184           0 :                 lldb::SBStream description;
    4185           0 :                 self->GetDescription (description);
    4186           0 :                 const char *desc = description.GetData();
    4187           0 :                 size_t desc_len = description.GetSize();
    4188           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4189           0 :                     --desc_len;
    4190           0 :                 if (desc_len > 0)
    4191           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4192             :                 else
    4193           0 :                     return lldb_private::PythonString("").release();
    4194             :         }
    4195           0 : SWIGINTERN PyObject *lldb_SBDebugger___str__(lldb::SBDebugger *self){
    4196           0 :                 lldb::SBStream description;
    4197           0 :                 self->GetDescription (description);
    4198           0 :                 const char *desc = description.GetData();
    4199           0 :                 size_t desc_len = description.GetSize();
    4200           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4201           0 :                     --desc_len;
    4202           0 :                 if (desc_len > 0)
    4203           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4204             :                 else
    4205           0 :                     return lldb_private::PythonString("").release();
    4206             :         }
    4207           0 : SWIGINTERN PyObject *lldb_SBDeclaration___str__(lldb::SBDeclaration *self){
    4208           0 :                 lldb::SBStream description;
    4209           0 :                 self->GetDescription (description);
    4210           0 :                 const char *desc = description.GetData();
    4211           0 :                 size_t desc_len = description.GetSize();
    4212           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4213           0 :                     --desc_len;
    4214           0 :                 if (desc_len > 0)
    4215           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4216             :                 else
    4217           0 :                     return lldb_private::PythonString("").release();
    4218             :         }
    4219         917 : SWIGINTERN PyObject *lldb_SBError___str__(lldb::SBError *self){
    4220        1834 :                 lldb::SBStream description;
    4221         917 :                 self->GetDescription (description);
    4222         917 :                 const char *desc = description.GetData();
    4223         917 :                 size_t desc_len = description.GetSize();
    4224         917 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4225           0 :                     --desc_len;
    4226         917 :                 if (desc_len > 0)
    4227        1834 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4228             :                 else
    4229           0 :                     return lldb_private::PythonString("").release();
    4230             :         }
    4231           0 : SWIGINTERN PyObject *lldb_SBFileSpec___str__(lldb::SBFileSpec *self){
    4232           0 :                 lldb::SBStream description;
    4233           0 :                 self->GetDescription (description);
    4234           0 :                 const char *desc = description.GetData();
    4235           0 :                 size_t desc_len = description.GetSize();
    4236           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4237           0 :                     --desc_len;
    4238           0 :                 if (desc_len > 0)
    4239           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4240             :                 else
    4241           0 :                     return lldb_private::PythonString("").release();
    4242             :         }
    4243           0 : SWIGINTERN PyObject *lldb_SBFrame___str__(lldb::SBFrame *self){
    4244           0 :                 lldb::SBStream description;
    4245           0 :                 self->GetDescription (description);
    4246           0 :                 const char *desc = description.GetData();
    4247           0 :                 size_t desc_len = description.GetSize();
    4248           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4249           0 :                     --desc_len;
    4250           0 :                 if (desc_len > 0)
    4251           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4252             :                 else
    4253           0 :                     return lldb_private::PythonString("").release();
    4254             :         }
    4255           0 : SWIGINTERN PyObject *lldb_SBFunction___str__(lldb::SBFunction *self){
    4256           0 :                 lldb::SBStream description;
    4257           0 :                 self->GetDescription (description);
    4258           0 :                 const char *desc = description.GetData();
    4259           0 :                 size_t desc_len = description.GetSize();
    4260           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4261           0 :                     --desc_len;
    4262           0 :                 if (desc_len > 0)
    4263           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4264             :                 else
    4265           0 :                     return lldb_private::PythonString("").release();
    4266             :         }
    4267           0 : SWIGINTERN PyObject *lldb_SBInstruction___str__(lldb::SBInstruction *self){
    4268           0 :                 lldb::SBStream description;
    4269           0 :                 self->GetDescription (description);
    4270           0 :                 const char *desc = description.GetData();
    4271           0 :                 size_t desc_len = description.GetSize();
    4272           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4273           0 :                     --desc_len;
    4274           0 :                 if (desc_len > 0)
    4275           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4276             :                 else
    4277           0 :                     return lldb_private::PythonString("").release();
    4278             :         }
    4279           0 : SWIGINTERN PyObject *lldb_SBInstructionList___str__(lldb::SBInstructionList *self){
    4280           0 :                 lldb::SBStream description;
    4281           0 :                 self->GetDescription (description);
    4282           0 :                 const char *desc = description.GetData();
    4283           0 :                 size_t desc_len = description.GetSize();
    4284           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4285           0 :                     --desc_len;
    4286           0 :                 if (desc_len > 0)
    4287           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4288             :                 else
    4289           0 :                     return lldb_private::PythonString("").release();
    4290             :         }
    4291           0 : SWIGINTERN PyObject *lldb_SBLineEntry___str__(lldb::SBLineEntry *self){
    4292           0 :                 lldb::SBStream description;
    4293           0 :                 self->GetDescription (description);
    4294           0 :                 const char *desc = description.GetData();
    4295           0 :                 size_t desc_len = description.GetSize();
    4296           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4297           0 :                     --desc_len;
    4298           0 :                 if (desc_len > 0)
    4299           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4300             :                 else
    4301           0 :                     return lldb_private::PythonString("").release();
    4302             :         }
    4303           0 : SWIGINTERN PyObject *lldb_SBMemoryRegionInfo___str__(lldb::SBMemoryRegionInfo *self){
    4304           0 :                 lldb::SBStream description;
    4305           0 :                 self->GetDescription (description);
    4306           0 :                 const char *desc = description.GetData();
    4307           0 :                 size_t desc_len = description.GetSize();
    4308           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4309           0 :                     --desc_len;
    4310           0 :                 if (desc_len > 0)
    4311           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4312             :                 else
    4313           0 :                     return lldb_private::PythonString("").release();
    4314             :         }
    4315          12 : SWIGINTERN PyObject *lldb_SBModule___str__(lldb::SBModule *self){
    4316          24 :                 lldb::SBStream description;
    4317          12 :                 self->GetDescription (description);
    4318          12 :                 const char *desc = description.GetData();
    4319          12 :                 size_t desc_len = description.GetSize();
    4320          12 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4321           0 :                     --desc_len;
    4322          12 :                 if (desc_len > 0)
    4323          24 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4324             :                 else
    4325           0 :                     return lldb_private::PythonString("").release();
    4326             :         }
    4327           0 : SWIGINTERN PyObject *lldb_SBModuleSpec___str__(lldb::SBModuleSpec *self){
    4328           0 :                 lldb::SBStream description;
    4329           0 :                 self->GetDescription (description);
    4330           0 :                 const char *desc = description.GetData();
    4331           0 :                 size_t desc_len = description.GetSize();
    4332           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4333           0 :                     --desc_len;
    4334           0 :                 if (desc_len > 0)
    4335           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4336             :                 else
    4337           0 :                     return lldb_private::PythonString("").release();
    4338             :         }
    4339           0 : SWIGINTERN PyObject *lldb_SBModuleSpecList___str__(lldb::SBModuleSpecList *self){
    4340           0 :                 lldb::SBStream description;
    4341           0 :                 self->GetDescription (description);
    4342           0 :                 const char *desc = description.GetData();
    4343           0 :                 size_t desc_len = description.GetSize();
    4344           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4345           0 :                     --desc_len;
    4346           0 :                 if (desc_len > 0)
    4347           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4348             :                 else
    4349           0 :                     return lldb_private::PythonString("").release();
    4350             :         }
    4351         919 : SWIGINTERN PyObject *lldb_SBProcess___str__(lldb::SBProcess *self){
    4352        1838 :                 lldb::SBStream description;
    4353         919 :                 self->GetDescription (description);
    4354         919 :                 const char *desc = description.GetData();
    4355         919 :                 size_t desc_len = description.GetSize();
    4356         919 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4357           0 :                     --desc_len;
    4358         919 :                 if (desc_len > 0)
    4359        1838 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4360             :                 else
    4361           0 :                     return lldb_private::PythonString("").release();
    4362             :         }
    4363          81 : SWIGINTERN PyObject *lldb_SBSection___str__(lldb::SBSection *self){
    4364         162 :                 lldb::SBStream description;
    4365          81 :                 self->GetDescription (description);
    4366          81 :                 const char *desc = description.GetData();
    4367          81 :                 size_t desc_len = description.GetSize();
    4368          81 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4369           0 :                     --desc_len;
    4370          81 :                 if (desc_len > 0)
    4371         162 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4372             :                 else
    4373           0 :                     return lldb_private::PythonString("").release();
    4374             :         }
    4375             : SWIGINTERN void lldb_SBStream_Print(lldb::SBStream *self,char const *str){
    4376           3 :             self->Printf("%s", str);
    4377             :         }
    4378             : SWIGINTERN void lldb_SBStream_write(lldb::SBStream *self,char const *str){
    4379           0 :             if (str)
    4380           0 :                 self->Printf("%s",str);
    4381             :         }
    4382             : SWIGINTERN void lldb_SBStream_flush(lldb::SBStream *self){}
    4383         476 : SWIGINTERN PyObject *lldb_SBSymbol___str__(lldb::SBSymbol *self){
    4384         952 :                 lldb::SBStream description;
    4385         476 :                 self->GetDescription (description);
    4386         476 :                 const char *desc = description.GetData();
    4387         476 :                 size_t desc_len = description.GetSize();
    4388         476 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4389           0 :                     --desc_len;
    4390         476 :                 if (desc_len > 0)
    4391         952 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4392             :                 else
    4393           0 :                     return lldb_private::PythonString("").release();
    4394             :         }
    4395           0 : SWIGINTERN PyObject *lldb_SBSymbolContext___str__(lldb::SBSymbolContext *self){
    4396           0 :                 lldb::SBStream description;
    4397           0 :                 self->GetDescription (description);
    4398           0 :                 const char *desc = description.GetData();
    4399           0 :                 size_t desc_len = description.GetSize();
    4400           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4401           0 :                     --desc_len;
    4402           0 :                 if (desc_len > 0)
    4403           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4404             :                 else
    4405           0 :                     return lldb_private::PythonString("").release();
    4406             :         }
    4407           0 : SWIGINTERN PyObject *lldb_SBSymbolContextList___str__(lldb::SBSymbolContextList *self){
    4408           0 :                 lldb::SBStream description;
    4409           0 :                 self->GetDescription (description);
    4410           0 :                 const char *desc = description.GetData();
    4411           0 :                 size_t desc_len = description.GetSize();
    4412           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4413           0 :                     --desc_len;
    4414           0 :                 if (desc_len > 0)
    4415           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4416             :                 else
    4417           0 :                     return lldb_private::PythonString("").release();
    4418             :         }
    4419             : 
    4420             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4421             : SWIGINTERN int
    4422           4 : SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
    4423             : {
    4424           4 :   int res = SWIG_TypeError;
    4425           4 :   if (PyLong_Check(obj)) {
    4426           0 :     long long v = PyLong_AsLongLong(obj);
    4427           0 :     if (!PyErr_Occurred()) {
    4428           0 :       if (val) *val = v;
    4429             :       return SWIG_OK;
    4430             :     } else {
    4431           0 :       PyErr_Clear();
    4432           0 :       res = SWIG_OverflowError;
    4433             :     }
    4434             :   } else {
    4435             :     long v;
    4436           4 :     res = SWIG_AsVal_long (obj,&v);
    4437           4 :     if (SWIG_IsOK(res)) {
    4438           4 :       if (val) *val = v;
    4439           4 :       return res;
    4440             :     }
    4441             :   }
    4442             : #ifdef SWIG_PYTHON_CAST_MODE
    4443             :   {
    4444             :     const double mant_max = 1LL << DBL_MANT_DIG;
    4445             :     const double mant_min = -mant_max;
    4446             :     double d;
    4447             :     res = SWIG_AsVal_double (obj,&d);
    4448             :     if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
    4449             :       return SWIG_OverflowError;
    4450             :     if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
    4451             :       if (val) *val = (long long)(d);
    4452             :       return SWIG_AddCast(res);
    4453             :     }
    4454             :     res = SWIG_TypeError;
    4455             :   }
    4456             : #endif
    4457             :   return res;
    4458             : }
    4459             : #endif
    4460             : 
    4461           0 : SWIGINTERN PyObject *lldb_SBTarget___str__(lldb::SBTarget *self){
    4462           0 :                 lldb::SBStream description;
    4463           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4464           0 :                 const char *desc = description.GetData();
    4465           0 :                 size_t desc_len = description.GetSize();
    4466           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4467           0 :                     --desc_len;
    4468           0 :                 if (desc_len > 0)
    4469           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4470             :                 else
    4471           0 :                     return lldb_private::PythonString("").release();
    4472             :         }
    4473           0 : SWIGINTERN PyObject *lldb_SBThread___str__(lldb::SBThread *self){
    4474           0 :                 lldb::SBStream description;
    4475           0 :                 self->GetDescription (description);
    4476           0 :                 const char *desc = description.GetData();
    4477           0 :                 size_t desc_len = description.GetSize();
    4478           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4479           0 :                     --desc_len;
    4480           0 :                 if (desc_len > 0)
    4481           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4482             :                 else
    4483           0 :                     return lldb_private::PythonString("").release();
    4484             :         }
    4485           0 : SWIGINTERN PyObject *lldb_SBTypeMember___str__(lldb::SBTypeMember *self){
    4486           0 :                 lldb::SBStream description;
    4487           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4488           0 :                 const char *desc = description.GetData();
    4489           0 :                 size_t desc_len = description.GetSize();
    4490           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4491           0 :                     --desc_len;
    4492           0 :                 if (desc_len > 0)
    4493           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4494             :                 else
    4495           0 :                     return lldb_private::PythonString("").release();
    4496             :         }
    4497           0 : SWIGINTERN PyObject *lldb_SBTypeMemberFunction___str__(lldb::SBTypeMemberFunction *self){
    4498           0 :                 lldb::SBStream description;
    4499           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4500           0 :                 const char *desc = description.GetData();
    4501           0 :                 size_t desc_len = description.GetSize();
    4502           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4503           0 :                     --desc_len;
    4504           0 :                 if (desc_len > 0)
    4505           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4506             :                 else
    4507           0 :                     return lldb_private::PythonString("").release();
    4508             :         }
    4509           0 : SWIGINTERN PyObject *lldb_SBType___str__(lldb::SBType *self){
    4510           0 :                 lldb::SBStream description;
    4511           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4512           0 :                 const char *desc = description.GetData();
    4513           0 :                 size_t desc_len = description.GetSize();
    4514           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4515           0 :                     --desc_len;
    4516           0 :                 if (desc_len > 0)
    4517           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4518             :                 else
    4519           0 :                     return lldb_private::PythonString("").release();
    4520             :         }
    4521           0 : SWIGINTERN PyObject *lldb_SBTypeCategory___str__(lldb::SBTypeCategory *self){
    4522           0 :                 lldb::SBStream description;
    4523           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4524           0 :                 const char *desc = description.GetData();
    4525           0 :                 size_t desc_len = description.GetSize();
    4526           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4527           0 :                     --desc_len;
    4528           0 :                 if (desc_len > 0)
    4529           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4530             :                 else
    4531           0 :                     return lldb_private::PythonString("").release();
    4532             :         }
    4533           0 : SWIGINTERN PyObject *lldb_SBTypeEnumMember___str__(lldb::SBTypeEnumMember *self){
    4534           0 :                 lldb::SBStream description;
    4535           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4536           0 :                 const char *desc = description.GetData();
    4537           0 :                 size_t desc_len = description.GetSize();
    4538           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4539           0 :                     --desc_len;
    4540           0 :                 if (desc_len > 0)
    4541           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4542             :                 else
    4543           0 :                     return lldb_private::PythonString("").release();
    4544             :         }
    4545           0 : SWIGINTERN PyObject *lldb_SBTypeFilter___str__(lldb::SBTypeFilter *self){
    4546           0 :                 lldb::SBStream description;
    4547           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4548           0 :                 const char *desc = description.GetData();
    4549           0 :                 size_t desc_len = description.GetSize();
    4550           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4551           0 :                     --desc_len;
    4552           0 :                 if (desc_len > 0)
    4553           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4554             :                 else
    4555           0 :                     return lldb_private::PythonString("").release();
    4556             :         }
    4557           0 : SWIGINTERN PyObject *lldb_SBTypeFormat___str__(lldb::SBTypeFormat *self){
    4558           0 :                 lldb::SBStream description;
    4559           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4560           0 :                 const char *desc = description.GetData();
    4561           0 :                 size_t desc_len = description.GetSize();
    4562           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4563           0 :                     --desc_len;
    4564           0 :                 if (desc_len > 0)
    4565           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4566             :                 else
    4567           0 :                     return lldb_private::PythonString("").release();
    4568             :         }
    4569           0 : SWIGINTERN PyObject *lldb_SBTypeNameSpecifier___str__(lldb::SBTypeNameSpecifier *self){
    4570           0 :                 lldb::SBStream description;
    4571           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4572           0 :                 const char *desc = description.GetData();
    4573           0 :                 size_t desc_len = description.GetSize();
    4574           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4575           0 :                     --desc_len;
    4576           0 :                 if (desc_len > 0)
    4577           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4578             :                 else
    4579           0 :                     return lldb_private::PythonString("").release();
    4580             :         }
    4581           0 : SWIGINTERN PyObject *lldb_SBTypeSummary___str__(lldb::SBTypeSummary *self){
    4582           0 :                 lldb::SBStream description;
    4583           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4584           0 :                 const char *desc = description.GetData();
    4585           0 :                 size_t desc_len = description.GetSize();
    4586           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4587           0 :                     --desc_len;
    4588           0 :                 if (desc_len > 0)
    4589           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4590             :                 else
    4591           0 :                     return lldb_private::PythonString("").release();
    4592             :         }
    4593           0 : SWIGINTERN PyObject *lldb_SBTypeSynthetic___str__(lldb::SBTypeSynthetic *self){
    4594           0 :                 lldb::SBStream description;
    4595           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4596           0 :                 const char *desc = description.GetData();
    4597           0 :                 size_t desc_len = description.GetSize();
    4598           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4599           0 :                     --desc_len;
    4600           0 :                 if (desc_len > 0)
    4601           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4602             :                 else
    4603           0 :                     return lldb_private::PythonString("").release();
    4604             :         }
    4605           1 : SWIGINTERN PyObject *lldb_SBValue___str__(lldb::SBValue *self){
    4606           2 :                 lldb::SBStream description;
    4607           1 :                 self->GetDescription (description);
    4608           1 :                 const char *desc = description.GetData();
    4609           1 :                 size_t desc_len = description.GetSize();
    4610           1 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4611           0 :                     --desc_len;
    4612           1 :                 if (desc_len > 0)
    4613           2 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4614             :                 else
    4615           0 :                     return lldb_private::PythonString("").release();
    4616             :         }
    4617           0 : SWIGINTERN PyObject *lldb_SBValueList___str__(lldb::SBValueList *self){
    4618           0 :                 lldb::SBStream description;
    4619           0 :                 const size_t n = self->GetSize();
    4620           0 :                 if (n)
    4621             :                 {
    4622           0 :                     for (size_t i=0; i<n; ++i)
    4623           0 :                         self->GetValueAtIndex(i).GetDescription(description);
    4624             :                 }
    4625             :                 else
    4626             :                 {
    4627           0 :                     description.Printf("<empty> lldb.SBValueList()");
    4628             :                 }
    4629           0 :                 const char *desc = description.GetData();
    4630           0 :                 size_t desc_len = description.GetSize();
    4631           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4632           0 :                     --desc_len;
    4633           0 :                 if (desc_len > 0)
    4634           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4635             :                 else
    4636           0 :                     return lldb_private::PythonString("").release();
    4637             :         }
    4638           0 : SWIGINTERN PyObject *lldb_SBWatchpoint___str__(lldb::SBWatchpoint *self){
    4639           0 :                 lldb::SBStream description;
    4640           0 :                 self->GetDescription (description, lldb::eDescriptionLevelVerbose);
    4641           0 :                 const char *desc = description.GetData();
    4642           0 :                 size_t desc_len = description.GetSize();
    4643           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4644           0 :                     --desc_len;
    4645           0 :                 if (desc_len > 0)
    4646           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4647             :                 else
    4648           0 :                     return lldb_private::PythonString("").release();
    4649             :         }
    4650             : 
    4651             : 
    4652             : template <typename T>
    4653             : PyObject *
    4654             : SBTypeToSWIGWrapper (T* item);
    4655             : 
    4656             : class PyErr_Cleaner
    4657             : {
    4658             : public:
    4659          47 :     PyErr_Cleaner(bool print=false) :
    4660          47 :     m_print(print)
    4661             :     {
    4662             :     }
    4663             : 
    4664          47 :     ~PyErr_Cleaner()
    4665          47 :     {
    4666          47 :         if (PyErr_Occurred())
    4667             :         {
    4668           0 :             if(m_print && !PyErr_ExceptionMatches(PyExc_SystemExit))
    4669           0 :                 PyErr_Print();
    4670           0 :             PyErr_Clear();
    4671             :         }
    4672          47 :     }
    4673             : 
    4674             : private:
    4675             :     bool m_print;
    4676             : };
    4677             : 
    4678             : 
    4679             : #ifdef __cplusplus
    4680             : extern "C" {
    4681             : #endif
    4682           3 : SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4683           3 :   PyObject *resultobj = 0;
    4684           3 :   lldb::SBAddress *result = 0 ;
    4685             :   
    4686           3 :   if (!PyArg_ParseTuple(args,(char *)":new_SBAddress")) SWIG_fail;
    4687             :   {
    4688           6 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4689           3 :     result = (lldb::SBAddress *)new lldb::SBAddress();
    4690           3 :     SWIG_PYTHON_THREAD_END_ALLOW;
    4691             :   }
    4692           3 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
    4693             :   return resultobj;
    4694           3 : fail:
    4695             :   return NULL;
    4696             : }
    4697             : 
    4698             : 
    4699           0 : SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4700           0 :   PyObject *resultobj = 0;
    4701           0 :   lldb::SBAddress *arg1 = 0 ;
    4702           0 :   void *argp1 = 0 ;
    4703           0 :   int res1 = 0 ;
    4704           0 :   PyObject * obj0 = 0 ;
    4705           0 :   lldb::SBAddress *result = 0 ;
    4706             :   
    4707           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBAddress",&obj0)) SWIG_fail;
    4708           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    4709           0 :   if (!SWIG_IsOK(res1)) {
    4710           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBAddress const &""'"); 
    4711             :   }
    4712           0 :   if (!argp1) {
    4713           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBAddress const &""'"); 
    4714             :   }
    4715           0 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    4716             :   {
    4717           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4718           0 :     result = (lldb::SBAddress *)new lldb::SBAddress((lldb::SBAddress const &)*arg1);
    4719           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    4720             :   }
    4721           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
    4722             :   return resultobj;
    4723             : fail:
    4724             :   return NULL;
    4725             : }
    4726             : 
    4727             : 
    4728           2 : SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4729           2 :   PyObject *resultobj = 0;
    4730           4 :   lldb::SBSection arg1 ;
    4731             :   lldb::addr_t arg2 ;
    4732             :   void *argp1 ;
    4733           2 :   int res1 = 0 ;
    4734             :   unsigned long long val2 ;
    4735           2 :   int ecode2 = 0 ;
    4736           2 :   PyObject * obj0 = 0 ;
    4737           2 :   PyObject * obj1 = 0 ;
    4738           2 :   lldb::SBAddress *result = 0 ;
    4739             :   
    4740           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:new_SBAddress",&obj0,&obj1)) SWIG_fail;
    4741             :   {
    4742           2 :     res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBSection,  0  | 0);
    4743           2 :     if (!SWIG_IsOK(res1)) {
    4744           0 :       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBSection""'"); 
    4745             :     }  
    4746           2 :     if (!argp1) {
    4747           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBSection""'");
    4748             :     } else {
    4749           2 :       lldb::SBSection * temp = reinterpret_cast< lldb::SBSection * >(argp1);
    4750           2 :       arg1 = *temp;
    4751           2 :       if (SWIG_IsNewObj(res1)) delete temp;
    4752             :     }
    4753             :   }
    4754           2 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    4755           2 :   if (!SWIG_IsOK(ecode2)) {
    4756           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
    4757             :   } 
    4758           2 :   arg2 = static_cast< lldb::addr_t >(val2);
    4759             :   {
    4760           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4761           2 :     result = (lldb::SBAddress *)new lldb::SBAddress(arg1,arg2);
    4762           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    4763             :   }
    4764           2 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
    4765             :   return resultobj;
    4766             : fail:
    4767             :   return NULL;
    4768             : }
    4769             : 
    4770             : 
    4771           1 : SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4772           1 :   PyObject *resultobj = 0;
    4773             :   lldb::addr_t arg1 ;
    4774           1 :   lldb::SBTarget *arg2 = 0 ;
    4775             :   unsigned long long val1 ;
    4776           1 :   int ecode1 = 0 ;
    4777           1 :   void *argp2 = 0 ;
    4778           1 :   int res2 = 0 ;
    4779           1 :   PyObject * obj0 = 0 ;
    4780           1 :   PyObject * obj1 = 0 ;
    4781           1 :   lldb::SBAddress *result = 0 ;
    4782             :   
    4783           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:new_SBAddress",&obj0,&obj1)) SWIG_fail;
    4784           1 :   ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
    4785           1 :   if (!SWIG_IsOK(ecode1)) {
    4786           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::addr_t""'");
    4787             :   } 
    4788           1 :   arg1 = static_cast< lldb::addr_t >(val1);
    4789           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBTarget,  0 );
    4790           1 :   if (!SWIG_IsOK(res2)) {
    4791           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBAddress" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
    4792             :   }
    4793           1 :   if (!argp2) {
    4794           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBAddress" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
    4795             :   }
    4796           1 :   arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
    4797             :   {
    4798           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4799           1 :     result = (lldb::SBAddress *)new lldb::SBAddress(arg1,*arg2);
    4800           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    4801             :   }
    4802           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
    4803             :   return resultobj;
    4804             : fail:
    4805             :   return NULL;
    4806             : }
    4807             : 
    4808             : 
    4809           6 : SWIGINTERN PyObject *_wrap_new_SBAddress(PyObject *self, PyObject *args) {
    4810             :   Py_ssize_t argc;
    4811           6 :   PyObject *argv[3] = {
    4812             :     0
    4813             :   };
    4814             :   Py_ssize_t ii;
    4815             :   
    4816           6 :   if (!PyTuple_Check(args)) SWIG_fail;
    4817           6 :   argc = args ? PyObject_Length(args) : 0;
    4818          12 :   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    4819           6 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    4820             :   }
    4821           6 :   if (argc == 0) {
    4822           3 :     return _wrap_new_SBAddress__SWIG_0(self, args);
    4823             :   }
    4824           3 :   if (argc == 1) {
    4825             :     int _v;
    4826           0 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBAddress, 0);
    4827           0 :     _v = SWIG_CheckState(res);
    4828             :     if (_v) {
    4829           0 :       return _wrap_new_SBAddress__SWIG_1(self, args);
    4830             :     }
    4831             :   }
    4832           3 :   if (argc == 2) {
    4833             :     int _v;
    4834           3 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBSection, 0);
    4835           3 :     _v = SWIG_CheckState(res);
    4836             :     if (_v) {
    4837             :       {
    4838           2 :         int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
    4839           2 :         _v = SWIG_CheckState(res);
    4840             :       }
    4841             :       if (_v) {
    4842           2 :         return _wrap_new_SBAddress__SWIG_2(self, args);
    4843             :       }
    4844             :     }
    4845             :   }
    4846           1 :   if (argc == 2) {
    4847             :     int _v;
    4848             :     {
    4849           1 :       int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
    4850           1 :       _v = SWIG_CheckState(res);
    4851             :     }
    4852             :     if (_v) {
    4853           1 :       void *vptr = 0;
    4854           1 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    4855           1 :       _v = SWIG_CheckState(res);
    4856             :       if (_v) {
    4857           1 :         return _wrap_new_SBAddress__SWIG_3(self, args);
    4858             :       }
    4859             :     }
    4860             :   }
    4861             :   
    4862           0 : fail:
    4863           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SBAddress'.\n"
    4864             :     "  Possible C/C++ prototypes are:\n"
    4865             :     "    lldb::SBAddress::SBAddress()\n"
    4866             :     "    lldb::SBAddress::SBAddress(lldb::SBAddress const &)\n"
    4867             :     "    lldb::SBAddress::SBAddress(lldb::SBSection,lldb::addr_t)\n"
    4868             :     "    lldb::SBAddress::SBAddress(lldb::addr_t,lldb::SBTarget &)\n");
    4869           0 :   return 0;
    4870             : }
    4871             : 
    4872             : 
    4873       44764 : SWIGINTERN PyObject *_wrap_delete_SBAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4874       44764 :   PyObject *resultobj = 0;
    4875       44764 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    4876       44764 :   void *argp1 = 0 ;
    4877       44764 :   int res1 = 0 ;
    4878       44764 :   PyObject * obj0 = 0 ;
    4879             :   
    4880       44764 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBAddress",&obj0)) SWIG_fail;
    4881       44764 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_DISOWN |  0 );
    4882       44764 :   if (!SWIG_IsOK(res1)) {
    4883           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    4884             :   }
    4885       44764 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    4886             :   {
    4887       89528 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4888       44764 :     delete arg1;
    4889       44764 :     SWIG_PYTHON_THREAD_END_ALLOW;
    4890             :   }
    4891       44764 :   resultobj = SWIG_Py_Void();
    4892       44764 :   return resultobj;
    4893           0 : fail:
    4894             :   return NULL;
    4895             : }
    4896             : 
    4897             : 
    4898           9 : SWIGINTERN PyObject *_wrap_SBAddress_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4899           9 :   PyObject *resultobj = 0;
    4900           9 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    4901           9 :   void *argp1 = 0 ;
    4902           9 :   int res1 = 0 ;
    4903           9 :   PyObject * obj0 = 0 ;
    4904             :   bool result;
    4905             :   
    4906           9 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_IsValid",&obj0)) SWIG_fail;
    4907           9 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    4908           9 :   if (!SWIG_IsOK(res1)) {
    4909           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_IsValid" "', argument " "1"" of type '" "lldb::SBAddress const *""'"); 
    4910             :   }
    4911           9 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    4912             :   {
    4913          18 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4914           9 :     result = (bool)((lldb::SBAddress const *)arg1)->IsValid();
    4915           9 :     SWIG_PYTHON_THREAD_END_ALLOW;
    4916             :   }
    4917           9 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    4918           9 :   return resultobj;
    4919           0 : fail:
    4920             :   return NULL;
    4921             : }
    4922             : 
    4923             : 
    4924           3 : SWIGINTERN PyObject *_wrap_SBAddress_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4925           3 :   PyObject *resultobj = 0;
    4926           3 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    4927           3 :   void *argp1 = 0 ;
    4928           3 :   int res1 = 0 ;
    4929           3 :   PyObject * obj0 = 0 ;
    4930             :   
    4931           3 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_Clear",&obj0)) SWIG_fail;
    4932           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    4933           3 :   if (!SWIG_IsOK(res1)) {
    4934           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_Clear" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    4935             :   }
    4936           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    4937             :   {
    4938           6 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4939           3 :     (arg1)->Clear();
    4940           3 :     SWIG_PYTHON_THREAD_END_ALLOW;
    4941             :   }
    4942           3 :   resultobj = SWIG_Py_Void();
    4943           3 :   return resultobj;
    4944           0 : fail:
    4945             :   return NULL;
    4946             : }
    4947             : 
    4948             : 
    4949       44649 : SWIGINTERN PyObject *_wrap_SBAddress_GetFileAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4950       44649 :   PyObject *resultobj = 0;
    4951       44649 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    4952       44649 :   void *argp1 = 0 ;
    4953       44649 :   int res1 = 0 ;
    4954       44649 :   PyObject * obj0 = 0 ;
    4955             :   lldb::addr_t result;
    4956             :   
    4957       44649 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetFileAddress",&obj0)) SWIG_fail;
    4958       44649 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    4959       44649 :   if (!SWIG_IsOK(res1)) {
    4960           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetFileAddress" "', argument " "1"" of type '" "lldb::SBAddress const *""'"); 
    4961             :   }
    4962       44649 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    4963             :   {
    4964       89298 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4965       44649 :     result = (lldb::addr_t)((lldb::SBAddress const *)arg1)->GetFileAddress();
    4966       44649 :     SWIG_PYTHON_THREAD_END_ALLOW;
    4967             :   }
    4968       44649 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    4969       44649 :   return resultobj;
    4970           0 : fail:
    4971             :   return NULL;
    4972             : }
    4973             : 
    4974             : 
    4975          30 : SWIGINTERN PyObject *_wrap_SBAddress_GetLoadAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4976          30 :   PyObject *resultobj = 0;
    4977          30 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    4978          30 :   lldb::SBTarget *arg2 = 0 ;
    4979          30 :   void *argp1 = 0 ;
    4980          30 :   int res1 = 0 ;
    4981          30 :   void *argp2 = 0 ;
    4982          30 :   int res2 = 0 ;
    4983          30 :   PyObject * obj0 = 0 ;
    4984          30 :   PyObject * obj1 = 0 ;
    4985             :   lldb::addr_t result;
    4986             :   
    4987          30 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAddress_GetLoadAddress",&obj0,&obj1)) SWIG_fail;
    4988          30 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    4989          30 :   if (!SWIG_IsOK(res1)) {
    4990           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetLoadAddress" "', argument " "1"" of type '" "lldb::SBAddress const *""'"); 
    4991             :   }
    4992          30 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    4993          30 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    4994          30 :   if (!SWIG_IsOK(res2)) {
    4995           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddress_GetLoadAddress" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
    4996             :   }
    4997          30 :   if (!argp2) {
    4998           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAddress_GetLoadAddress" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
    4999             :   }
    5000          30 :   arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
    5001             :   {
    5002          60 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5003          30 :     result = (lldb::addr_t)((lldb::SBAddress const *)arg1)->GetLoadAddress((lldb::SBTarget const &)*arg2);
    5004          30 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5005             :   }
    5006          30 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    5007          30 :   return resultobj;
    5008           0 : fail:
    5009             :   return NULL;
    5010             : }
    5011             : 
    5012             : 
    5013           3 : SWIGINTERN PyObject *_wrap_SBAddress_SetLoadAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5014           3 :   PyObject *resultobj = 0;
    5015           3 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5016             :   lldb::addr_t arg2 ;
    5017           3 :   lldb::SBTarget *arg3 = 0 ;
    5018           3 :   void *argp1 = 0 ;
    5019           3 :   int res1 = 0 ;
    5020             :   unsigned long long val2 ;
    5021           3 :   int ecode2 = 0 ;
    5022           3 :   void *argp3 = 0 ;
    5023           3 :   int res3 = 0 ;
    5024           3 :   PyObject * obj0 = 0 ;
    5025           3 :   PyObject * obj1 = 0 ;
    5026           3 :   PyObject * obj2 = 0 ;
    5027             :   
    5028           3 :   if (!PyArg_ParseTuple(args,(char *)"OOO:SBAddress_SetLoadAddress",&obj0,&obj1,&obj2)) SWIG_fail;
    5029           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5030           3 :   if (!SWIG_IsOK(res1)) {
    5031           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_SetLoadAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5032             :   }
    5033           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5034           3 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    5035           3 :   if (!SWIG_IsOK(ecode2)) {
    5036           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAddress_SetLoadAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
    5037             :   } 
    5038           3 :   arg2 = static_cast< lldb::addr_t >(val2);
    5039           3 :   res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_lldb__SBTarget,  0 );
    5040           3 :   if (!SWIG_IsOK(res3)) {
    5041           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBAddress_SetLoadAddress" "', argument " "3"" of type '" "lldb::SBTarget &""'"); 
    5042             :   }
    5043           3 :   if (!argp3) {
    5044           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAddress_SetLoadAddress" "', argument " "3"" of type '" "lldb::SBTarget &""'"); 
    5045             :   }
    5046           3 :   arg3 = reinterpret_cast< lldb::SBTarget * >(argp3);
    5047             :   {
    5048           6 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5049           3 :     (arg1)->SetLoadAddress(arg2,*arg3);
    5050           3 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5051             :   }
    5052           3 :   resultobj = SWIG_Py_Void();
    5053           3 :   return resultobj;
    5054           0 : fail:
    5055             :   return NULL;
    5056             : }
    5057             : 
    5058             : 
    5059           3 : SWIGINTERN PyObject *_wrap_SBAddress_OffsetAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5060           3 :   PyObject *resultobj = 0;
    5061           3 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5062             :   lldb::addr_t arg2 ;
    5063           3 :   void *argp1 = 0 ;
    5064           3 :   int res1 = 0 ;
    5065             :   unsigned long long val2 ;
    5066           3 :   int ecode2 = 0 ;
    5067           3 :   PyObject * obj0 = 0 ;
    5068           3 :   PyObject * obj1 = 0 ;
    5069             :   bool result;
    5070             :   
    5071           3 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAddress_OffsetAddress",&obj0,&obj1)) SWIG_fail;
    5072           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5073           3 :   if (!SWIG_IsOK(res1)) {
    5074           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_OffsetAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5075             :   }
    5076           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5077           3 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    5078           3 :   if (!SWIG_IsOK(ecode2)) {
    5079           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAddress_OffsetAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
    5080             :   } 
    5081           3 :   arg2 = static_cast< lldb::addr_t >(val2);
    5082             :   {
    5083           6 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5084           3 :     result = (bool)(arg1)->OffsetAddress(arg2);
    5085           3 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5086             :   }
    5087           3 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    5088           3 :   return resultobj;
    5089           0 : fail:
    5090             :   return NULL;
    5091             : }
    5092             : 
    5093             : 
    5094           3 : SWIGINTERN PyObject *_wrap_SBAddress_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5095           3 :   PyObject *resultobj = 0;
    5096           3 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5097           3 :   lldb::SBStream *arg2 = 0 ;
    5098           3 :   void *argp1 = 0 ;
    5099           3 :   int res1 = 0 ;
    5100           3 :   void *argp2 = 0 ;
    5101           3 :   int res2 = 0 ;
    5102           3 :   PyObject * obj0 = 0 ;
    5103           3 :   PyObject * obj1 = 0 ;
    5104             :   bool result;
    5105             :   
    5106           3 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAddress_GetDescription",&obj0,&obj1)) SWIG_fail;
    5107           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5108           3 :   if (!SWIG_IsOK(res1)) {
    5109           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetDescription" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5110             :   }
    5111           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5112           3 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
    5113           3 :   if (!SWIG_IsOK(res2)) {
    5114           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddress_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    5115             :   }
    5116           3 :   if (!argp2) {
    5117           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAddress_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    5118             :   }
    5119           3 :   arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
    5120             :   {
    5121           6 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5122           3 :     result = (bool)(arg1)->GetDescription(*arg2);
    5123           3 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5124             :   }
    5125           3 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    5126           3 :   return resultobj;
    5127           0 : fail:
    5128             :   return NULL;
    5129             : }
    5130             : 
    5131             : 
    5132           5 : SWIGINTERN PyObject *_wrap_SBAddress_GetSection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5133           5 :   PyObject *resultobj = 0;
    5134           5 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5135           5 :   void *argp1 = 0 ;
    5136           5 :   int res1 = 0 ;
    5137           5 :   PyObject * obj0 = 0 ;
    5138          10 :   lldb::SBSection result;
    5139             :   
    5140           5 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetSection",&obj0)) SWIG_fail;
    5141           5 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5142           5 :   if (!SWIG_IsOK(res1)) {
    5143           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetSection" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5144             :   }
    5145           5 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5146             :   {
    5147          10 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5148           5 :     result = (arg1)->GetSection();
    5149           5 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5150             :   }
    5151           5 :   resultobj = SWIG_NewPointerObj((new lldb::SBSection(static_cast< const lldb::SBSection& >(result))), SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_OWN |  0 );
    5152           5 :   return resultobj;
    5153           0 : fail:
    5154             :   return NULL;
    5155             : }
    5156             : 
    5157             : 
    5158           0 : SWIGINTERN PyObject *_wrap_SBAddress_GetOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5159           0 :   PyObject *resultobj = 0;
    5160           0 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5161           0 :   void *argp1 = 0 ;
    5162           0 :   int res1 = 0 ;
    5163           0 :   PyObject * obj0 = 0 ;
    5164             :   lldb::addr_t result;
    5165             :   
    5166           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetOffset",&obj0)) SWIG_fail;
    5167           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5168           0 :   if (!SWIG_IsOK(res1)) {
    5169           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetOffset" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5170             :   }
    5171           0 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5172             :   {
    5173           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5174           0 :     result = (lldb::addr_t)(arg1)->GetOffset();
    5175           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5176             :   }
    5177           0 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    5178           0 :   return resultobj;
    5179           0 : fail:
    5180             :   return NULL;
    5181             : }
    5182             : 
    5183             : 
    5184           0 : SWIGINTERN PyObject *_wrap_SBAddress_SetAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5185           0 :   PyObject *resultobj = 0;
    5186           0 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5187           0 :   lldb::SBSection arg2 ;
    5188             :   lldb::addr_t arg3 ;
    5189           0 :   void *argp1 = 0 ;
    5190           0 :   int res1 = 0 ;
    5191             :   void *argp2 ;
    5192           0 :   int res2 = 0 ;
    5193             :   unsigned long long val3 ;
    5194           0 :   int ecode3 = 0 ;
    5195           0 :   PyObject * obj0 = 0 ;
    5196           0 :   PyObject * obj1 = 0 ;
    5197           0 :   PyObject * obj2 = 0 ;
    5198             :   
    5199           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:SBAddress_SetAddress",&obj0,&obj1,&obj2)) SWIG_fail;
    5200           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5201           0 :   if (!SWIG_IsOK(res1)) {
    5202           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_SetAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5203             :   }
    5204           0 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5205             :   {
    5206           0 :     res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBSection,  0  | 0);
    5207           0 :     if (!SWIG_IsOK(res2)) {
    5208           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddress_SetAddress" "', argument " "2"" of type '" "lldb::SBSection""'"); 
    5209             :     }  
    5210           0 :     if (!argp2) {
    5211           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAddress_SetAddress" "', argument " "2"" of type '" "lldb::SBSection""'");
    5212             :     } else {
    5213           0 :       lldb::SBSection * temp = reinterpret_cast< lldb::SBSection * >(argp2);
    5214           0 :       arg2 = *temp;
    5215           0 :       if (SWIG_IsNewObj(res2)) delete temp;
    5216             :     }
    5217             :   }
    5218           0 :   ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
    5219           0 :   if (!SWIG_IsOK(ecode3)) {
    5220           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBAddress_SetAddress" "', argument " "3"" of type '" "lldb::addr_t""'");
    5221             :   } 
    5222           0 :   arg3 = static_cast< lldb::addr_t >(val3);
    5223             :   {
    5224           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5225           0 :     (arg1)->SetAddress(arg2,arg3);
    5226           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5227             :   }
    5228           0 :   resultobj = SWIG_Py_Void();
    5229           0 :   return resultobj;
    5230           0 : fail:
    5231             :   return NULL;
    5232             : }
    5233             : 
    5234             : 
    5235           0 : SWIGINTERN PyObject *_wrap_SBAddress_GetAddressClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5236           0 :   PyObject *resultobj = 0;
    5237           0 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5238           0 :   void *argp1 = 0 ;
    5239           0 :   int res1 = 0 ;
    5240           0 :   PyObject * obj0 = 0 ;
    5241             :   lldb::AddressClass result;
    5242             :   
    5243           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetAddressClass",&obj0)) SWIG_fail;
    5244           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5245           0 :   if (!SWIG_IsOK(res1)) {
    5246           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetAddressClass" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5247             :   }
    5248           0 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5249             :   {
    5250           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5251           0 :     result = (lldb::AddressClass)(arg1)->GetAddressClass();
    5252           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5253             :   }
    5254           0 :   resultobj = SWIG_From_int(static_cast< int >(result));
    5255           0 :   return resultobj;
    5256           0 : fail:
    5257             :   return NULL;
    5258             : }
    5259             : 
    5260             : 
    5261           7 : SWIGINTERN PyObject *_wrap_SBAddress_GetSymbolContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5262           7 :   PyObject *resultobj = 0;
    5263           7 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5264             :   uint32_t arg2 ;
    5265           7 :   void *argp1 = 0 ;
    5266           7 :   int res1 = 0 ;
    5267             :   unsigned int val2 ;
    5268           7 :   int ecode2 = 0 ;
    5269           7 :   PyObject * obj0 = 0 ;
    5270           7 :   PyObject * obj1 = 0 ;
    5271          14 :   lldb::SBSymbolContext result;
    5272             :   
    5273           7 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAddress_GetSymbolContext",&obj0,&obj1)) SWIG_fail;
    5274           7 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5275           7 :   if (!SWIG_IsOK(res1)) {
    5276           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetSymbolContext" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5277             :   }
    5278           7 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5279          14 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    5280           7 :   if (!SWIG_IsOK(ecode2)) {
    5281           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAddress_GetSymbolContext" "', argument " "2"" of type '" "uint32_t""'");
    5282             :   } 
    5283           7 :   arg2 = static_cast< uint32_t >(val2);
    5284             :   {
    5285          14 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5286           7 :     result = (arg1)->GetSymbolContext(arg2);
    5287           7 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5288             :   }
    5289           7 :   resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContext(static_cast< const lldb::SBSymbolContext& >(result))), SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_OWN |  0 );
    5290           7 :   return resultobj;
    5291           0 : fail:
    5292             :   return NULL;
    5293             : }
    5294             : 
    5295             : 
    5296           3 : SWIGINTERN PyObject *_wrap_SBAddress_GetModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5297           3 :   PyObject *resultobj = 0;
    5298           3 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5299           3 :   void *argp1 = 0 ;
    5300           3 :   int res1 = 0 ;
    5301           3 :   PyObject * obj0 = 0 ;
    5302           6 :   lldb::SBModule result;
    5303             :   
    5304           3 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetModule",&obj0)) SWIG_fail;
    5305           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5306           3 :   if (!SWIG_IsOK(res1)) {
    5307           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetModule" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5308             :   }
    5309           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5310             :   {
    5311           6 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5312           3 :     result = (arg1)->GetModule();
    5313           3 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5314             :   }
    5315           3 :   resultobj = SWIG_NewPointerObj((new lldb::SBModule(static_cast< const lldb::SBModule& >(result))), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
    5316           3 :   return resultobj;
    5317           0 : fail:
    5318             :   return NULL;
    5319             : }
    5320             : 
    5321             : 
    5322          11 : SWIGINTERN PyObject *_wrap_SBAddress_GetCompileUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5323          11 :   PyObject *resultobj = 0;
    5324          11 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5325          11 :   void *argp1 = 0 ;
    5326          11 :   int res1 = 0 ;
    5327          11 :   PyObject * obj0 = 0 ;
    5328          22 :   lldb::SBCompileUnit result;
    5329             :   
    5330          11 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetCompileUnit",&obj0)) SWIG_fail;
    5331          11 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5332          11 :   if (!SWIG_IsOK(res1)) {
    5333           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetCompileUnit" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5334             :   }
    5335          11 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5336             :   {
    5337          22 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5338          11 :     result = (arg1)->GetCompileUnit();
    5339          11 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5340             :   }
    5341          11 :   resultobj = SWIG_NewPointerObj((new lldb::SBCompileUnit(static_cast< const lldb::SBCompileUnit& >(result))), SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_OWN |  0 );
    5342          11 :   return resultobj;
    5343           0 : fail:
    5344             :   return NULL;
    5345             : }
    5346             : 
    5347             : 
    5348          57 : SWIGINTERN PyObject *_wrap_SBAddress_GetFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5349          57 :   PyObject *resultobj = 0;
    5350          57 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5351          57 :   void *argp1 = 0 ;
    5352          57 :   int res1 = 0 ;
    5353          57 :   PyObject * obj0 = 0 ;
    5354         114 :   lldb::SBFunction result;
    5355             :   
    5356          57 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetFunction",&obj0)) SWIG_fail;
    5357          57 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5358          57 :   if (!SWIG_IsOK(res1)) {
    5359           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetFunction" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5360             :   }
    5361          57 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5362             :   {
    5363         114 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5364          57 :     result = (arg1)->GetFunction();
    5365          57 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5366             :   }
    5367          57 :   resultobj = SWIG_NewPointerObj((new lldb::SBFunction(static_cast< const lldb::SBFunction& >(result))), SWIGTYPE_p_lldb__SBFunction, SWIG_POINTER_OWN |  0 );
    5368          57 :   return resultobj;
    5369           0 : fail:
    5370             :   return NULL;
    5371             : }
    5372             : 
    5373             : 
    5374           3 : SWIGINTERN PyObject *_wrap_SBAddress_GetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5375           3 :   PyObject *resultobj = 0;
    5376           3 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5377           3 :   void *argp1 = 0 ;
    5378           3 :   int res1 = 0 ;
    5379           3 :   PyObject * obj0 = 0 ;
    5380           6 :   lldb::SBBlock result;
    5381             :   
    5382           3 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetBlock",&obj0)) SWIG_fail;
    5383           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5384           3 :   if (!SWIG_IsOK(res1)) {
    5385           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetBlock" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5386             :   }
    5387           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5388             :   {
    5389           6 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5390           3 :     result = (arg1)->GetBlock();
    5391           3 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5392             :   }
    5393           3 :   resultobj = SWIG_NewPointerObj((new lldb::SBBlock(static_cast< const lldb::SBBlock& >(result))), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
    5394           3 :   return resultobj;
    5395           0 : fail:
    5396             :   return NULL;
    5397             : }
    5398             : 
    5399             : 
    5400           3 : SWIGINTERN PyObject *_wrap_SBAddress_GetSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5401           3 :   PyObject *resultobj = 0;
    5402           3 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5403           3 :   void *argp1 = 0 ;
    5404           3 :   int res1 = 0 ;
    5405           3 :   PyObject * obj0 = 0 ;
    5406           6 :   lldb::SBSymbol result;
    5407             :   
    5408           3 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetSymbol",&obj0)) SWIG_fail;
    5409           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5410           3 :   if (!SWIG_IsOK(res1)) {
    5411           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetSymbol" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5412             :   }
    5413           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5414             :   {
    5415           6 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5416           3 :     result = (arg1)->GetSymbol();
    5417           3 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5418             :   }
    5419           3 :   resultobj = SWIG_NewPointerObj((new lldb::SBSymbol(static_cast< const lldb::SBSymbol& >(result))), SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_OWN |  0 );
    5420           3 :   return resultobj;
    5421           0 : fail:
    5422             :   return NULL;
    5423             : }
    5424             : 
    5425             : 
    5426           5 : SWIGINTERN PyObject *_wrap_SBAddress_GetLineEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5427           5 :   PyObject *resultobj = 0;
    5428           5 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5429           5 :   void *argp1 = 0 ;
    5430           5 :   int res1 = 0 ;
    5431           5 :   PyObject * obj0 = 0 ;
    5432          10 :   lldb::SBLineEntry result;
    5433             :   
    5434           5 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetLineEntry",&obj0)) SWIG_fail;
    5435           5 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5436           5 :   if (!SWIG_IsOK(res1)) {
    5437           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetLineEntry" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5438             :   }
    5439           5 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5440             :   {
    5441          10 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5442           5 :     result = (arg1)->GetLineEntry();
    5443           5 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5444             :   }
    5445           5 :   resultobj = SWIG_NewPointerObj((new lldb::SBLineEntry(static_cast< const lldb::SBLineEntry& >(result))), SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_OWN |  0 );
    5446           5 :   return resultobj;
    5447           0 : fail:
    5448             :   return NULL;
    5449             : }
    5450             : 
    5451             : 
    5452           0 : SWIGINTERN PyObject *_wrap_SBAddress___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5453           0 :   PyObject *resultobj = 0;
    5454           0 :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5455           0 :   void *argp1 = 0 ;
    5456           0 :   int res1 = 0 ;
    5457           0 :   PyObject * obj0 = 0 ;
    5458           0 :   PyObject *result = 0 ;
    5459             :   
    5460           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress___str__",&obj0)) SWIG_fail;
    5461           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5462           0 :   if (!SWIG_IsOK(res1)) {
    5463           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress___str__" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5464             :   }
    5465           0 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5466             :   {
    5467           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5468           0 :     result = (PyObject *)lldb_SBAddress___str__(arg1);
    5469           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5470             :   }
    5471           0 :   resultobj = result;
    5472           0 :   return resultobj;
    5473           0 : fail:
    5474             :   return NULL;
    5475             : }
    5476             : 
    5477             : 
    5478         605 : SWIGINTERN PyObject *SBAddress_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5479             :   PyObject *obj;
    5480         605 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    5481        1210 :   SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBAddress, SWIG_NewClientData(obj));
    5482         605 :   return SWIG_Py_Void();
    5483             : }
    5484             : 
    5485           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5486           0 :   PyObject *resultobj = 0;
    5487           0 :   lldb::SBAttachInfo *result = 0 ;
    5488             :   
    5489           0 :   if (!PyArg_ParseTuple(args,(char *)":new_SBAttachInfo")) SWIG_fail;
    5490             :   {
    5491           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5492           0 :     result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo();
    5493           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5494             :   }
    5495           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
    5496             :   return resultobj;
    5497           0 : fail:
    5498             :   return NULL;
    5499             : }
    5500             : 
    5501             : 
    5502           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5503           0 :   PyObject *resultobj = 0;
    5504             :   lldb::pid_t arg1 ;
    5505             :   unsigned long long val1 ;
    5506           0 :   int ecode1 = 0 ;
    5507           0 :   PyObject * obj0 = 0 ;
    5508           0 :   lldb::SBAttachInfo *result = 0 ;
    5509             :   
    5510           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBAttachInfo",&obj0)) SWIG_fail;
    5511           0 :   ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
    5512           0 :   if (!SWIG_IsOK(ecode1)) {
    5513           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "lldb::pid_t""'");
    5514             :   } 
    5515           0 :   arg1 = static_cast< lldb::pid_t >(val1);
    5516             :   {
    5517           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5518           0 :     result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo(arg1);
    5519           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5520             :   }
    5521           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
    5522             :   return resultobj;
    5523             : fail:
    5524             :   return NULL;
    5525             : }
    5526             : 
    5527             : 
    5528           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5529           0 :   PyObject *resultobj = 0;
    5530           0 :   char *arg1 = (char *) 0 ;
    5531             :   bool arg2 ;
    5532             :   int res1 ;
    5533           0 :   char *buf1 = 0 ;
    5534           0 :   int alloc1 = 0 ;
    5535             :   bool val2 ;
    5536           0 :   int ecode2 = 0 ;
    5537           0 :   PyObject * obj0 = 0 ;
    5538           0 :   PyObject * obj1 = 0 ;
    5539           0 :   lldb::SBAttachInfo *result = 0 ;
    5540             :   
    5541           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:new_SBAttachInfo",&obj0,&obj1)) SWIG_fail;
    5542           0 :   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
    5543           0 :   if (!SWIG_IsOK(res1)) {
    5544           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "char const *""'");
    5545             :   }
    5546           0 :   arg1 = reinterpret_cast< char * >(buf1);
    5547           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    5548             :   if (!SWIG_IsOK(ecode2)) {
    5549           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBAttachInfo" "', argument " "2"" of type '" "bool""'");
    5550             :   } 
    5551           0 :   arg2 = static_cast< bool >(val2);
    5552             :   {
    5553           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5554           0 :     result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((char const *)arg1,arg2);
    5555           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5556             :   }
    5557           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
    5558           0 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    5559             :   return resultobj;
    5560           0 : fail:
    5561           0 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    5562             :   return NULL;
    5563             : }
    5564             : 
    5565             : 
    5566           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5567           0 :   PyObject *resultobj = 0;
    5568           0 :   char *arg1 = (char *) 0 ;
    5569             :   bool arg2 ;
    5570             :   bool arg3 ;
    5571             :   int res1 ;
    5572           0 :   char *buf1 = 0 ;
    5573           0 :   int alloc1 = 0 ;
    5574             :   bool val2 ;
    5575           0 :   int ecode2 = 0 ;
    5576             :   bool val3 ;
    5577           0 :   int ecode3 = 0 ;
    5578           0 :   PyObject * obj0 = 0 ;
    5579           0 :   PyObject * obj1 = 0 ;
    5580           0 :   PyObject * obj2 = 0 ;
    5581           0 :   lldb::SBAttachInfo *result = 0 ;
    5582             :   
    5583           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:new_SBAttachInfo",&obj0,&obj1,&obj2)) SWIG_fail;
    5584           0 :   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
    5585           0 :   if (!SWIG_IsOK(res1)) {
    5586           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "char const *""'");
    5587             :   }
    5588           0 :   arg1 = reinterpret_cast< char * >(buf1);
    5589           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    5590             :   if (!SWIG_IsOK(ecode2)) {
    5591           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBAttachInfo" "', argument " "2"" of type '" "bool""'");
    5592             :   } 
    5593           0 :   arg2 = static_cast< bool >(val2);
    5594           0 :   ecode3 = SWIG_AsVal_bool(obj2, &val3);
    5595             :   if (!SWIG_IsOK(ecode3)) {
    5596           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBAttachInfo" "', argument " "3"" of type '" "bool""'");
    5597             :   } 
    5598           0 :   arg3 = static_cast< bool >(val3);
    5599             :   {
    5600           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5601           0 :     result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((char const *)arg1,arg2,arg3);
    5602           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5603             :   }
    5604           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
    5605           0 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    5606             :   return resultobj;
    5607           0 : fail:
    5608           0 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    5609             :   return NULL;
    5610             : }
    5611             : 
    5612             : 
    5613           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5614           0 :   PyObject *resultobj = 0;
    5615           0 :   lldb::SBAttachInfo *arg1 = 0 ;
    5616           0 :   void *argp1 = 0 ;
    5617           0 :   int res1 = 0 ;
    5618           0 :   PyObject * obj0 = 0 ;
    5619           0 :   lldb::SBAttachInfo *result = 0 ;
    5620             :   
    5621           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBAttachInfo",&obj0)) SWIG_fail;
    5622           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBAttachInfo,  0  | 0);
    5623           0 :   if (!SWIG_IsOK(res1)) {
    5624           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "lldb::SBAttachInfo const &""'"); 
    5625             :   }
    5626           0 :   if (!argp1) {
    5627           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "lldb::SBAttachInfo const &""'"); 
    5628             :   }
    5629           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5630             :   {
    5631           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5632           0 :     result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((lldb::SBAttachInfo const &)*arg1);
    5633           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5634             :   }
    5635           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
    5636             :   return resultobj;
    5637             : fail:
    5638             :   return NULL;
    5639             : }
    5640             : 
    5641             : 
    5642           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo(PyObject *self, PyObject *args) {
    5643             :   Py_ssize_t argc;
    5644           0 :   PyObject *argv[4] = {
    5645             :     0
    5646             :   };
    5647             :   Py_ssize_t ii;
    5648             :   
    5649           0 :   if (!PyTuple_Check(args)) SWIG_fail;
    5650           0 :   argc = args ? PyObject_Length(args) : 0;
    5651           0 :   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    5652           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    5653             :   }
    5654           0 :   if (argc == 0) {
    5655           0 :     return _wrap_new_SBAttachInfo__SWIG_0(self, args);
    5656             :   }
    5657           0 :   if (argc == 1) {
    5658             :     int _v;
    5659           0 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    5660           0 :     _v = SWIG_CheckState(res);
    5661             :     if (_v) {
    5662           0 :       return _wrap_new_SBAttachInfo__SWIG_4(self, args);
    5663             :     }
    5664             :   }
    5665           0 :   if (argc == 1) {
    5666             :     int _v;
    5667             :     {
    5668           0 :       int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
    5669           0 :       _v = SWIG_CheckState(res);
    5670             :     }
    5671             :     if (_v) {
    5672           0 :       return _wrap_new_SBAttachInfo__SWIG_1(self, args);
    5673             :     }
    5674             :   }
    5675           0 :   if (argc == 2) {
    5676             :     int _v;
    5677           0 :     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    5678           0 :     _v = SWIG_CheckState(res);
    5679             :     if (_v) {
    5680             :       {
    5681           0 :         int res = SWIG_AsVal_bool(argv[1], NULL);
    5682           0 :         _v = SWIG_CheckState(res);
    5683             :       }
    5684             :       if (_v) {
    5685           0 :         return _wrap_new_SBAttachInfo__SWIG_2(self, args);
    5686             :       }
    5687             :     }
    5688             :   }
    5689           0 :   if (argc == 3) {
    5690             :     int _v;
    5691           0 :     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    5692           0 :     _v = SWIG_CheckState(res);
    5693             :     if (_v) {
    5694             :       {
    5695           0 :         int res = SWIG_AsVal_bool(argv[1], NULL);
    5696           0 :         _v = SWIG_CheckState(res);
    5697             :       }
    5698             :       if (_v) {
    5699             :         {
    5700           0 :           int res = SWIG_AsVal_bool(argv[2], NULL);
    5701           0 :           _v = SWIG_CheckState(res);
    5702             :         }
    5703             :         if (_v) {
    5704           0 :           return _wrap_new_SBAttachInfo__SWIG_3(self, args);
    5705             :         }
    5706             :       }
    5707             :     }
    5708             :   }
    5709             :   
    5710           0 : fail:
    5711           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SBAttachInfo'.\n"
    5712             :     "  Possible C/C++ prototypes are:\n"
    5713             :     "    lldb::SBAttachInfo::SBAttachInfo()\n"
    5714             :     "    lldb::SBAttachInfo::SBAttachInfo(lldb::pid_t)\n"
    5715             :     "    lldb::SBAttachInfo::SBAttachInfo(char const *,bool)\n"
    5716             :     "    lldb::SBAttachInfo::SBAttachInfo(char const *,bool,bool)\n"
    5717             :     "    lldb::SBAttachInfo::SBAttachInfo(lldb::SBAttachInfo const &)\n");
    5718           0 :   return 0;
    5719             : }
    5720             : 
    5721             : 
    5722           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetProcessID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5723           0 :   PyObject *resultobj = 0;
    5724           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5725           0 :   void *argp1 = 0 ;
    5726           0 :   int res1 = 0 ;
    5727           0 :   PyObject * obj0 = 0 ;
    5728             :   lldb::pid_t result;
    5729             :   
    5730           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetProcessID",&obj0)) SWIG_fail;
    5731           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5732           0 :   if (!SWIG_IsOK(res1)) {
    5733           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5734             :   }
    5735           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5736             :   {
    5737           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5738           0 :     result = (lldb::pid_t)(arg1)->GetProcessID();
    5739           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5740             :   }
    5741           0 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    5742           0 :   return resultobj;
    5743           0 : fail:
    5744             :   return NULL;
    5745             : }
    5746             : 
    5747             : 
    5748           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetProcessID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5749           0 :   PyObject *resultobj = 0;
    5750           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5751             :   lldb::pid_t arg2 ;
    5752           0 :   void *argp1 = 0 ;
    5753           0 :   int res1 = 0 ;
    5754             :   unsigned long long val2 ;
    5755           0 :   int ecode2 = 0 ;
    5756           0 :   PyObject * obj0 = 0 ;
    5757           0 :   PyObject * obj1 = 0 ;
    5758             :   
    5759           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetProcessID",&obj0,&obj1)) SWIG_fail;
    5760           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5761           0 :   if (!SWIG_IsOK(res1)) {
    5762           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5763             :   }
    5764           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5765           0 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    5766           0 :   if (!SWIG_IsOK(ecode2)) {
    5767           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetProcessID" "', argument " "2"" of type '" "lldb::pid_t""'");
    5768             :   } 
    5769           0 :   arg2 = static_cast< lldb::pid_t >(val2);
    5770             :   {
    5771           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5772           0 :     (arg1)->SetProcessID(arg2);
    5773           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5774             :   }
    5775           0 :   resultobj = SWIG_Py_Void();
    5776           0 :   return resultobj;
    5777           0 : fail:
    5778             :   return NULL;
    5779             : }
    5780             : 
    5781             : 
    5782           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5783           0 :   PyObject *resultobj = 0;
    5784           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5785           0 :   char *arg2 = (char *) 0 ;
    5786           0 :   void *argp1 = 0 ;
    5787           0 :   int res1 = 0 ;
    5788             :   int res2 ;
    5789           0 :   char *buf2 = 0 ;
    5790           0 :   int alloc2 = 0 ;
    5791           0 :   PyObject * obj0 = 0 ;
    5792           0 :   PyObject * obj1 = 0 ;
    5793             :   
    5794           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetExecutable",&obj0,&obj1)) SWIG_fail;
    5795           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5796           0 :   if (!SWIG_IsOK(res1)) {
    5797           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetExecutable" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5798             :   }
    5799           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5800           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    5801           0 :   if (!SWIG_IsOK(res2)) {
    5802           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetExecutable" "', argument " "2"" of type '" "char const *""'");
    5803             :   }
    5804           0 :   arg2 = reinterpret_cast< char * >(buf2);
    5805             :   {
    5806           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5807           0 :     (arg1)->SetExecutable((char const *)arg2);
    5808           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5809             :   }
    5810           0 :   resultobj = SWIG_Py_Void();
    5811           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    5812             :   return resultobj;
    5813           0 : fail:
    5814           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    5815             :   return NULL;
    5816             : }
    5817             : 
    5818             : 
    5819           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5820           0 :   PyObject *resultobj = 0;
    5821           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5822           0 :   lldb::SBFileSpec arg2 ;
    5823           0 :   void *argp1 = 0 ;
    5824           0 :   int res1 = 0 ;
    5825             :   void *argp2 ;
    5826           0 :   int res2 = 0 ;
    5827           0 :   PyObject * obj0 = 0 ;
    5828           0 :   PyObject * obj1 = 0 ;
    5829             :   
    5830           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetExecutable",&obj0,&obj1)) SWIG_fail;
    5831           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5832           0 :   if (!SWIG_IsOK(res1)) {
    5833           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetExecutable" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5834             :   }
    5835           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5836             :   {
    5837           0 :     res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
    5838           0 :     if (!SWIG_IsOK(res2)) {
    5839           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetExecutable" "', argument " "2"" of type '" "lldb::SBFileSpec""'"); 
    5840             :     }  
    5841           0 :     if (!argp2) {
    5842           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAttachInfo_SetExecutable" "', argument " "2"" of type '" "lldb::SBFileSpec""'");
    5843             :     } else {
    5844           0 :       lldb::SBFileSpec * temp = reinterpret_cast< lldb::SBFileSpec * >(argp2);
    5845           0 :       arg2 = *temp;
    5846           0 :       if (SWIG_IsNewObj(res2)) delete temp;
    5847             :     }
    5848             :   }
    5849             :   {
    5850           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5851           0 :     (arg1)->SetExecutable(arg2);
    5852           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5853             :   }
    5854           0 :   resultobj = SWIG_Py_Void();
    5855             :   return resultobj;
    5856             : fail:
    5857             :   return NULL;
    5858             : }
    5859             : 
    5860             : 
    5861           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable(PyObject *self, PyObject *args) {
    5862             :   Py_ssize_t argc;
    5863           0 :   PyObject *argv[3] = {
    5864             :     0
    5865             :   };
    5866             :   Py_ssize_t ii;
    5867             :   
    5868           0 :   if (!PyTuple_Check(args)) SWIG_fail;
    5869           0 :   argc = args ? PyObject_Length(args) : 0;
    5870           0 :   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    5871           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    5872             :   }
    5873           0 :   if (argc == 2) {
    5874             :     int _v;
    5875           0 :     void *vptr = 0;
    5876           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    5877           0 :     _v = SWIG_CheckState(res);
    5878             :     if (_v) {
    5879           0 :       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFileSpec, 0);
    5880           0 :       _v = SWIG_CheckState(res);
    5881             :       if (_v) {
    5882           0 :         return _wrap_SBAttachInfo_SetExecutable__SWIG_1(self, args);
    5883             :       }
    5884             :     }
    5885             :   }
    5886           0 :   if (argc == 2) {
    5887             :     int _v;
    5888           0 :     void *vptr = 0;
    5889           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    5890           0 :     _v = SWIG_CheckState(res);
    5891             :     if (_v) {
    5892           0 :       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
    5893           0 :       _v = SWIG_CheckState(res);
    5894             :       if (_v) {
    5895           0 :         return _wrap_SBAttachInfo_SetExecutable__SWIG_0(self, args);
    5896             :       }
    5897             :     }
    5898             :   }
    5899             :   
    5900           0 : fail:
    5901           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SBAttachInfo_SetExecutable'.\n"
    5902             :     "  Possible C/C++ prototypes are:\n"
    5903             :     "    lldb::SBAttachInfo::SetExecutable(char const *)\n"
    5904             :     "    lldb::SBAttachInfo::SetExecutable(lldb::SBFileSpec)\n");
    5905           0 :   return 0;
    5906             : }
    5907             : 
    5908             : 
    5909           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetWaitForLaunch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5910           0 :   PyObject *resultobj = 0;
    5911           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5912           0 :   void *argp1 = 0 ;
    5913           0 :   int res1 = 0 ;
    5914           0 :   PyObject * obj0 = 0 ;
    5915             :   bool result;
    5916             :   
    5917           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetWaitForLaunch",&obj0)) SWIG_fail;
    5918           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5919           0 :   if (!SWIG_IsOK(res1)) {
    5920           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetWaitForLaunch" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5921             :   }
    5922           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5923             :   {
    5924           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5925           0 :     result = (bool)(arg1)->GetWaitForLaunch();
    5926           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5927             :   }
    5928           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    5929           0 :   return resultobj;
    5930           0 : fail:
    5931             :   return NULL;
    5932             : }
    5933             : 
    5934             : 
    5935           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5936           0 :   PyObject *resultobj = 0;
    5937           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5938             :   bool arg2 ;
    5939           0 :   void *argp1 = 0 ;
    5940           0 :   int res1 = 0 ;
    5941             :   bool val2 ;
    5942           0 :   int ecode2 = 0 ;
    5943           0 :   PyObject * obj0 = 0 ;
    5944           0 :   PyObject * obj1 = 0 ;
    5945             :   
    5946           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetWaitForLaunch",&obj0,&obj1)) SWIG_fail;
    5947           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5948           0 :   if (!SWIG_IsOK(res1)) {
    5949           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5950             :   }
    5951           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5952           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    5953             :   if (!SWIG_IsOK(ecode2)) {
    5954           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "2"" of type '" "bool""'");
    5955             :   } 
    5956           0 :   arg2 = static_cast< bool >(val2);
    5957             :   {
    5958           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5959           0 :     (arg1)->SetWaitForLaunch(arg2);
    5960           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    5961             :   }
    5962           0 :   resultobj = SWIG_Py_Void();
    5963             :   return resultobj;
    5964             : fail:
    5965             :   return NULL;
    5966             : }
    5967             : 
    5968             : 
    5969           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5970           0 :   PyObject *resultobj = 0;
    5971           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5972             :   bool arg2 ;
    5973             :   bool arg3 ;
    5974           0 :   void *argp1 = 0 ;
    5975           0 :   int res1 = 0 ;
    5976             :   bool val2 ;
    5977           0 :   int ecode2 = 0 ;
    5978             :   bool val3 ;
    5979           0 :   int ecode3 = 0 ;
    5980           0 :   PyObject * obj0 = 0 ;
    5981           0 :   PyObject * obj1 = 0 ;
    5982           0 :   PyObject * obj2 = 0 ;
    5983             :   
    5984           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:SBAttachInfo_SetWaitForLaunch",&obj0,&obj1,&obj2)) SWIG_fail;
    5985           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5986           0 :   if (!SWIG_IsOK(res1)) {
    5987           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5988             :   }
    5989           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5990           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    5991             :   if (!SWIG_IsOK(ecode2)) {
    5992           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "2"" of type '" "bool""'");
    5993             :   } 
    5994           0 :   arg2 = static_cast< bool >(val2);
    5995           0 :   ecode3 = SWIG_AsVal_bool(obj2, &val3);
    5996             :   if (!SWIG_IsOK(ecode3)) {
    5997           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "3"" of type '" "bool""'");
    5998             :   } 
    5999           0 :   arg3 = static_cast< bool >(val3);
    6000             :   {
    6001           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6002           0 :     (arg1)->SetWaitForLaunch(arg2,arg3);
    6003           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6004             :   }
    6005           0 :   resultobj = SWIG_Py_Void();
    6006             :   return resultobj;
    6007             : fail:
    6008             :   return NULL;
    6009             : }
    6010             : 
    6011             : 
    6012           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch(PyObject *self, PyObject *args) {
    6013             :   Py_ssize_t argc;
    6014           0 :   PyObject *argv[4] = {
    6015             :     0
    6016             :   };
    6017             :   Py_ssize_t ii;
    6018             :   
    6019           0 :   if (!PyTuple_Check(args)) SWIG_fail;
    6020           0 :   argc = args ? PyObject_Length(args) : 0;
    6021           0 :   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    6022           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    6023             :   }
    6024           0 :   if (argc == 2) {
    6025             :     int _v;
    6026           0 :     void *vptr = 0;
    6027           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    6028           0 :     _v = SWIG_CheckState(res);
    6029             :     if (_v) {
    6030             :       {
    6031           0 :         int res = SWIG_AsVal_bool(argv[1], NULL);
    6032           0 :         _v = SWIG_CheckState(res);
    6033             :       }
    6034             :       if (_v) {
    6035           0 :         return _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(self, args);
    6036             :       }
    6037             :     }
    6038             :   }
    6039           0 :   if (argc == 3) {
    6040             :     int _v;
    6041           0 :     void *vptr = 0;
    6042           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    6043           0 :     _v = SWIG_CheckState(res);
    6044             :     if (_v) {
    6045             :       {
    6046           0 :         int res = SWIG_AsVal_bool(argv[1], NULL);
    6047           0 :         _v = SWIG_CheckState(res);
    6048             :       }
    6049             :       if (_v) {
    6050             :         {
    6051           0 :           int res = SWIG_AsVal_bool(argv[2], NULL);
    6052           0 :           _v = SWIG_CheckState(res);
    6053             :         }
    6054             :         if (_v) {
    6055           0 :           return _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_1(self, args);
    6056             :         }
    6057             :       }
    6058             :     }
    6059             :   }
    6060             :   
    6061           0 : fail:
    6062           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SBAttachInfo_SetWaitForLaunch'.\n"
    6063             :     "  Possible C/C++ prototypes are:\n"
    6064             :     "    lldb::SBAttachInfo::SetWaitForLaunch(bool)\n"
    6065             :     "    lldb::SBAttachInfo::SetWaitForLaunch(bool,bool)\n");
    6066           0 :   return 0;
    6067             : }
    6068             : 
    6069             : 
    6070           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetIgnoreExisting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6071           0 :   PyObject *resultobj = 0;
    6072           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6073           0 :   void *argp1 = 0 ;
    6074           0 :   int res1 = 0 ;
    6075           0 :   PyObject * obj0 = 0 ;
    6076             :   bool result;
    6077             :   
    6078           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetIgnoreExisting",&obj0)) SWIG_fail;
    6079           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6080           0 :   if (!SWIG_IsOK(res1)) {
    6081           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetIgnoreExisting" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6082             :   }
    6083           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6084             :   {
    6085           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6086           0 :     result = (bool)(arg1)->GetIgnoreExisting();
    6087           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6088             :   }
    6089           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6090           0 :   return resultobj;
    6091           0 : fail:
    6092             :   return NULL;
    6093             : }
    6094             : 
    6095             : 
    6096           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetIgnoreExisting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6097           0 :   PyObject *resultobj = 0;
    6098           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6099             :   bool arg2 ;
    6100           0 :   void *argp1 = 0 ;
    6101           0 :   int res1 = 0 ;
    6102             :   bool val2 ;
    6103           0 :   int ecode2 = 0 ;
    6104           0 :   PyObject * obj0 = 0 ;
    6105           0 :   PyObject * obj1 = 0 ;
    6106             :   
    6107           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetIgnoreExisting",&obj0,&obj1)) SWIG_fail;
    6108           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6109           0 :   if (!SWIG_IsOK(res1)) {
    6110           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetIgnoreExisting" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6111             :   }
    6112           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6113           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    6114             :   if (!SWIG_IsOK(ecode2)) {
    6115           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetIgnoreExisting" "', argument " "2"" of type '" "bool""'");
    6116             :   } 
    6117           0 :   arg2 = static_cast< bool >(val2);
    6118             :   {
    6119           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6120           0 :     (arg1)->SetIgnoreExisting(arg2);
    6121           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6122             :   }
    6123           0 :   resultobj = SWIG_Py_Void();
    6124           0 :   return resultobj;
    6125           0 : fail:
    6126             :   return NULL;
    6127             : }
    6128             : 
    6129             : 
    6130           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetResumeCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6131           0 :   PyObject *resultobj = 0;
    6132           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6133           0 :   void *argp1 = 0 ;
    6134           0 :   int res1 = 0 ;
    6135           0 :   PyObject * obj0 = 0 ;
    6136             :   uint32_t result;
    6137             :   
    6138           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetResumeCount",&obj0)) SWIG_fail;
    6139           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6140           0 :   if (!SWIG_IsOK(res1)) {
    6141           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetResumeCount" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6142             :   }
    6143           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6144             :   {
    6145           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6146           0 :     result = (uint32_t)(arg1)->GetResumeCount();
    6147           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6148             :   }
    6149           0 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    6150           0 :   return resultobj;
    6151           0 : fail:
    6152             :   return NULL;
    6153             : }
    6154             : 
    6155             : 
    6156           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetResumeCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6157           0 :   PyObject *resultobj = 0;
    6158           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6159             :   uint32_t arg2 ;
    6160           0 :   void *argp1 = 0 ;
    6161           0 :   int res1 = 0 ;
    6162             :   unsigned int val2 ;
    6163           0 :   int ecode2 = 0 ;
    6164           0 :   PyObject * obj0 = 0 ;
    6165           0 :   PyObject * obj1 = 0 ;
    6166             :   
    6167           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetResumeCount",&obj0,&obj1)) SWIG_fail;
    6168           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6169           0 :   if (!SWIG_IsOK(res1)) {
    6170           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetResumeCount" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6171             :   }
    6172           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6173           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    6174           0 :   if (!SWIG_IsOK(ecode2)) {
    6175           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetResumeCount" "', argument " "2"" of type '" "uint32_t""'");
    6176             :   } 
    6177           0 :   arg2 = static_cast< uint32_t >(val2);
    6178             :   {
    6179           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6180           0 :     (arg1)->SetResumeCount(arg2);
    6181           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6182             :   }
    6183           0 :   resultobj = SWIG_Py_Void();
    6184           0 :   return resultobj;
    6185           0 : fail:
    6186             :   return NULL;
    6187             : }
    6188             : 
    6189             : 
    6190           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetProcessPluginName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6191           0 :   PyObject *resultobj = 0;
    6192           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6193           0 :   void *argp1 = 0 ;
    6194           0 :   int res1 = 0 ;
    6195           0 :   PyObject * obj0 = 0 ;
    6196           0 :   char *result = 0 ;
    6197             :   
    6198           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetProcessPluginName",&obj0)) SWIG_fail;
    6199           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6200           0 :   if (!SWIG_IsOK(res1)) {
    6201           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetProcessPluginName" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6202             :   }
    6203           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6204             :   {
    6205           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6206           0 :     result = (char *)(arg1)->GetProcessPluginName();
    6207           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6208             :   }
    6209           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
    6210           0 :   return resultobj;
    6211           0 : fail:
    6212             :   return NULL;
    6213             : }
    6214             : 
    6215             : 
    6216           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetProcessPluginName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6217           0 :   PyObject *resultobj = 0;
    6218           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6219           0 :   char *arg2 = (char *) 0 ;
    6220           0 :   void *argp1 = 0 ;
    6221           0 :   int res1 = 0 ;
    6222             :   int res2 ;
    6223           0 :   char *buf2 = 0 ;
    6224           0 :   int alloc2 = 0 ;
    6225           0 :   PyObject * obj0 = 0 ;
    6226           0 :   PyObject * obj1 = 0 ;
    6227             :   
    6228           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetProcessPluginName",&obj0,&obj1)) SWIG_fail;
    6229           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6230           0 :   if (!SWIG_IsOK(res1)) {
    6231           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetProcessPluginName" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6232             :   }
    6233           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6234           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    6235           0 :   if (!SWIG_IsOK(res2)) {
    6236           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetProcessPluginName" "', argument " "2"" of type '" "char const *""'");
    6237             :   }
    6238           0 :   arg2 = reinterpret_cast< char * >(buf2);
    6239             :   {
    6240           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6241           0 :     (arg1)->SetProcessPluginName((char const *)arg2);
    6242           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6243             :   }
    6244           0 :   resultobj = SWIG_Py_Void();
    6245           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    6246             :   return resultobj;
    6247           0 : fail:
    6248           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    6249             :   return NULL;
    6250             : }
    6251             : 
    6252             : 
    6253           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetUserID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6254           0 :   PyObject *resultobj = 0;
    6255           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6256           0 :   void *argp1 = 0 ;
    6257           0 :   int res1 = 0 ;
    6258           0 :   PyObject * obj0 = 0 ;
    6259             :   uint32_t result;
    6260             :   
    6261           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetUserID",&obj0)) SWIG_fail;
    6262           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6263           0 :   if (!SWIG_IsOK(res1)) {
    6264           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6265             :   }
    6266           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6267             :   {
    6268           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6269           0 :     result = (uint32_t)(arg1)->GetUserID();
    6270           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6271             :   }
    6272           0 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    6273           0 :   return resultobj;
    6274           0 : fail:
    6275             :   return NULL;
    6276             : }
    6277             : 
    6278             : 
    6279           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetGroupID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6280           0 :   PyObject *resultobj = 0;
    6281           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6282           0 :   void *argp1 = 0 ;
    6283           0 :   int res1 = 0 ;
    6284           0 :   PyObject * obj0 = 0 ;
    6285             :   uint32_t result;
    6286             :   
    6287           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetGroupID",&obj0)) SWIG_fail;
    6288           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6289           0 :   if (!SWIG_IsOK(res1)) {
    6290           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6291             :   }
    6292           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6293             :   {
    6294           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6295           0 :     result = (uint32_t)(arg1)->GetGroupID();
    6296           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6297             :   }
    6298           0 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    6299           0 :   return resultobj;
    6300           0 : fail:
    6301             :   return NULL;
    6302             : }
    6303             : 
    6304             : 
    6305           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_UserIDIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6306           0 :   PyObject *resultobj = 0;
    6307           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6308           0 :   void *argp1 = 0 ;
    6309           0 :   int res1 = 0 ;
    6310           0 :   PyObject * obj0 = 0 ;
    6311             :   bool result;
    6312             :   
    6313           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_UserIDIsValid",&obj0)) SWIG_fail;
    6314           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6315           0 :   if (!SWIG_IsOK(res1)) {
    6316           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_UserIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6317             :   }
    6318           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6319             :   {
    6320           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6321           0 :     result = (bool)(arg1)->UserIDIsValid();
    6322           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6323             :   }
    6324           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6325           0 :   return resultobj;
    6326           0 : fail:
    6327             :   return NULL;
    6328             : }
    6329             : 
    6330             : 
    6331           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GroupIDIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6332           0 :   PyObject *resultobj = 0;
    6333           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6334           0 :   void *argp1 = 0 ;
    6335           0 :   int res1 = 0 ;
    6336           0 :   PyObject * obj0 = 0 ;
    6337             :   bool result;
    6338             :   
    6339           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GroupIDIsValid",&obj0)) SWIG_fail;
    6340           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6341           0 :   if (!SWIG_IsOK(res1)) {
    6342           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GroupIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6343             :   }
    6344           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6345             :   {
    6346           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6347           0 :     result = (bool)(arg1)->GroupIDIsValid();
    6348           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6349             :   }
    6350           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6351           0 :   return resultobj;
    6352           0 : fail:
    6353             :   return NULL;
    6354             : }
    6355             : 
    6356             : 
    6357           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetUserID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6358           0 :   PyObject *resultobj = 0;
    6359           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6360             :   uint32_t arg2 ;
    6361           0 :   void *argp1 = 0 ;
    6362           0 :   int res1 = 0 ;
    6363             :   unsigned int val2 ;
    6364           0 :   int ecode2 = 0 ;
    6365           0 :   PyObject * obj0 = 0 ;
    6366           0 :   PyObject * obj1 = 0 ;
    6367             :   
    6368           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetUserID",&obj0,&obj1)) SWIG_fail;
    6369           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6370           0 :   if (!SWIG_IsOK(res1)) {
    6371           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6372             :   }
    6373           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6374           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    6375           0 :   if (!SWIG_IsOK(ecode2)) {
    6376           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetUserID" "', argument " "2"" of type '" "uint32_t""'");
    6377             :   } 
    6378           0 :   arg2 = static_cast< uint32_t >(val2);
    6379             :   {
    6380           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6381           0 :     (arg1)->SetUserID(arg2);
    6382           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6383             :   }
    6384           0 :   resultobj = SWIG_Py_Void();
    6385           0 :   return resultobj;
    6386           0 : fail:
    6387             :   return NULL;
    6388             : }
    6389             : 
    6390             : 
    6391           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetGroupID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6392           0 :   PyObject *resultobj = 0;
    6393           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6394             :   uint32_t arg2 ;
    6395           0 :   void *argp1 = 0 ;
    6396           0 :   int res1 = 0 ;
    6397             :   unsigned int val2 ;
    6398           0 :   int ecode2 = 0 ;
    6399           0 :   PyObject * obj0 = 0 ;
    6400           0 :   PyObject * obj1 = 0 ;
    6401             :   
    6402           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetGroupID",&obj0,&obj1)) SWIG_fail;
    6403           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6404           0 :   if (!SWIG_IsOK(res1)) {
    6405           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6406             :   }
    6407           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6408           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    6409           0 :   if (!SWIG_IsOK(ecode2)) {
    6410           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetGroupID" "', argument " "2"" of type '" "uint32_t""'");
    6411             :   } 
    6412           0 :   arg2 = static_cast< uint32_t >(val2);
    6413             :   {
    6414           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6415           0 :     (arg1)->SetGroupID(arg2);
    6416           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6417             :   }
    6418           0 :   resultobj = SWIG_Py_Void();
    6419           0 :   return resultobj;
    6420           0 : fail:
    6421             :   return NULL;
    6422             : }
    6423             : 
    6424             : 
    6425           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetEffectiveUserID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6426           0 :   PyObject *resultobj = 0;
    6427           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6428           0 :   void *argp1 = 0 ;
    6429           0 :   int res1 = 0 ;
    6430           0 :   PyObject * obj0 = 0 ;
    6431             :   uint32_t result;
    6432             :   
    6433           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetEffectiveUserID",&obj0)) SWIG_fail;
    6434           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6435           0 :   if (!SWIG_IsOK(res1)) {
    6436           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetEffectiveUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6437             :   }
    6438           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6439             :   {
    6440           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6441           0 :     result = (uint32_t)(arg1)->GetEffectiveUserID();
    6442           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6443             :   }
    6444           0 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    6445           0 :   return resultobj;
    6446           0 : fail:
    6447             :   return NULL;
    6448             : }
    6449             : 
    6450             : 
    6451           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetEffectiveGroupID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6452           0 :   PyObject *resultobj = 0;
    6453           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6454           0 :   void *argp1 = 0 ;
    6455           0 :   int res1 = 0 ;
    6456           0 :   PyObject * obj0 = 0 ;
    6457             :   uint32_t result;
    6458             :   
    6459           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetEffectiveGroupID",&obj0)) SWIG_fail;
    6460           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6461           0 :   if (!SWIG_IsOK(res1)) {
    6462           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetEffectiveGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6463             :   }
    6464           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6465             :   {
    6466           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6467           0 :     result = (uint32_t)(arg1)->GetEffectiveGroupID();
    6468           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6469             :   }
    6470           0 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    6471           0 :   return resultobj;
    6472           0 : fail:
    6473             :   return NULL;
    6474             : }
    6475             : 
    6476             : 
    6477           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_EffectiveUserIDIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6478           0 :   PyObject *resultobj = 0;
    6479           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6480           0 :   void *argp1 = 0 ;
    6481           0 :   int res1 = 0 ;
    6482           0 :   PyObject * obj0 = 0 ;
    6483             :   bool result;
    6484             :   
    6485           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_EffectiveUserIDIsValid",&obj0)) SWIG_fail;
    6486           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6487           0 :   if (!SWIG_IsOK(res1)) {
    6488           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_EffectiveUserIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6489             :   }
    6490           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6491             :   {
    6492           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6493           0 :     result = (bool)(arg1)->EffectiveUserIDIsValid();
    6494           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6495             :   }
    6496           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6497           0 :   return resultobj;
    6498           0 : fail:
    6499             :   return NULL;
    6500             : }
    6501             : 
    6502             : 
    6503           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_EffectiveGroupIDIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6504           0 :   PyObject *resultobj = 0;
    6505           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6506           0 :   void *argp1 = 0 ;
    6507           0 :   int res1 = 0 ;
    6508           0 :   PyObject * obj0 = 0 ;
    6509             :   bool result;
    6510             :   
    6511           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_EffectiveGroupIDIsValid",&obj0)) SWIG_fail;
    6512           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6513           0 :   if (!SWIG_IsOK(res1)) {
    6514           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_EffectiveGroupIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6515             :   }
    6516           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6517             :   {
    6518           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6519           0 :     result = (bool)(arg1)->EffectiveGroupIDIsValid();
    6520           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6521             :   }
    6522           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6523           0 :   return resultobj;
    6524           0 : fail:
    6525             :   return NULL;
    6526             : }
    6527             : 
    6528             : 
    6529           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetEffectiveUserID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6530           0 :   PyObject *resultobj = 0;
    6531           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6532             :   uint32_t arg2 ;
    6533           0 :   void *argp1 = 0 ;
    6534           0 :   int res1 = 0 ;
    6535             :   unsigned int val2 ;
    6536           0 :   int ecode2 = 0 ;
    6537           0 :   PyObject * obj0 = 0 ;
    6538           0 :   PyObject * obj1 = 0 ;
    6539             :   
    6540           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetEffectiveUserID",&obj0,&obj1)) SWIG_fail;
    6541           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6542           0 :   if (!SWIG_IsOK(res1)) {
    6543           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetEffectiveUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6544             :   }
    6545           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6546           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    6547           0 :   if (!SWIG_IsOK(ecode2)) {
    6548           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetEffectiveUserID" "', argument " "2"" of type '" "uint32_t""'");
    6549             :   } 
    6550           0 :   arg2 = static_cast< uint32_t >(val2);
    6551             :   {
    6552           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6553           0 :     (arg1)->SetEffectiveUserID(arg2);
    6554           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6555             :   }
    6556           0 :   resultobj = SWIG_Py_Void();
    6557           0 :   return resultobj;
    6558           0 : fail:
    6559             :   return NULL;
    6560             : }
    6561             : 
    6562             : 
    6563           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetEffectiveGroupID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6564           0 :   PyObject *resultobj = 0;
    6565           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6566             :   uint32_t arg2 ;
    6567           0 :   void *argp1 = 0 ;
    6568           0 :   int res1 = 0 ;
    6569             :   unsigned int val2 ;
    6570           0 :   int ecode2 = 0 ;
    6571           0 :   PyObject * obj0 = 0 ;
    6572           0 :   PyObject * obj1 = 0 ;
    6573             :   
    6574           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetEffectiveGroupID",&obj0,&obj1)) SWIG_fail;
    6575           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6576           0 :   if (!SWIG_IsOK(res1)) {
    6577           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetEffectiveGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6578             :   }
    6579           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6580           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    6581           0 :   if (!SWIG_IsOK(ecode2)) {
    6582           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetEffectiveGroupID" "', argument " "2"" of type '" "uint32_t""'");
    6583             :   } 
    6584           0 :   arg2 = static_cast< uint32_t >(val2);
    6585             :   {
    6586           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6587           0 :     (arg1)->SetEffectiveGroupID(arg2);
    6588           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6589             :   }
    6590           0 :   resultobj = SWIG_Py_Void();
    6591           0 :   return resultobj;
    6592           0 : fail:
    6593             :   return NULL;
    6594             : }
    6595             : 
    6596             : 
    6597           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetParentProcessID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6598           0 :   PyObject *resultobj = 0;
    6599           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6600           0 :   void *argp1 = 0 ;
    6601           0 :   int res1 = 0 ;
    6602           0 :   PyObject * obj0 = 0 ;
    6603             :   lldb::pid_t result;
    6604             :   
    6605           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetParentProcessID",&obj0)) SWIG_fail;
    6606           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6607           0 :   if (!SWIG_IsOK(res1)) {
    6608           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetParentProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6609             :   }
    6610           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6611             :   {
    6612           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6613           0 :     result = (lldb::pid_t)(arg1)->GetParentProcessID();
    6614           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6615             :   }
    6616           0 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    6617           0 :   return resultobj;
    6618           0 : fail:
    6619             :   return NULL;
    6620             : }
    6621             : 
    6622             : 
    6623           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetParentProcessID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6624           0 :   PyObject *resultobj = 0;
    6625           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6626             :   lldb::pid_t arg2 ;
    6627           0 :   void *argp1 = 0 ;
    6628           0 :   int res1 = 0 ;
    6629             :   unsigned long long val2 ;
    6630           0 :   int ecode2 = 0 ;
    6631           0 :   PyObject * obj0 = 0 ;
    6632           0 :   PyObject * obj1 = 0 ;
    6633             :   
    6634           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetParentProcessID",&obj0,&obj1)) SWIG_fail;
    6635           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6636           0 :   if (!SWIG_IsOK(res1)) {
    6637           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetParentProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6638             :   }
    6639           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6640           0 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    6641           0 :   if (!SWIG_IsOK(ecode2)) {
    6642           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetParentProcessID" "', argument " "2"" of type '" "lldb::pid_t""'");
    6643             :   } 
    6644           0 :   arg2 = static_cast< lldb::pid_t >(val2);
    6645             :   {
    6646           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6647           0 :     (arg1)->SetParentProcessID(arg2);
    6648           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6649             :   }
    6650           0 :   resultobj = SWIG_Py_Void();
    6651           0 :   return resultobj;
    6652           0 : fail:
    6653             :   return NULL;
    6654             : }
    6655             : 
    6656             : 
    6657           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_ParentProcessIDIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6658           0 :   PyObject *resultobj = 0;
    6659           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6660           0 :   void *argp1 = 0 ;
    6661           0 :   int res1 = 0 ;
    6662           0 :   PyObject * obj0 = 0 ;
    6663             :   bool result;
    6664             :   
    6665           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_ParentProcessIDIsValid",&obj0)) SWIG_fail;
    6666           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6667           0 :   if (!SWIG_IsOK(res1)) {
    6668           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_ParentProcessIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6669             :   }
    6670           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6671             :   {
    6672           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6673           0 :     result = (bool)(arg1)->ParentProcessIDIsValid();
    6674           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6675             :   }
    6676           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6677           0 :   return resultobj;
    6678           0 : fail:
    6679             :   return NULL;
    6680             : }
    6681             : 
    6682             : 
    6683           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6684           0 :   PyObject *resultobj = 0;
    6685           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6686           0 :   void *argp1 = 0 ;
    6687           0 :   int res1 = 0 ;
    6688           0 :   PyObject * obj0 = 0 ;
    6689           0 :   lldb::SBListener result;
    6690             :   
    6691           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetListener",&obj0)) SWIG_fail;
    6692           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6693           0 :   if (!SWIG_IsOK(res1)) {
    6694           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetListener" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6695             :   }
    6696           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6697             :   {
    6698           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6699           0 :     result = (arg1)->GetListener();
    6700           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6701             :   }
    6702           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBListener(static_cast< const lldb::SBListener& >(result))), SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_OWN |  0 );
    6703           0 :   return resultobj;
    6704           0 : fail:
    6705             :   return NULL;
    6706             : }
    6707             : 
    6708             : 
    6709           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6710           0 :   PyObject *resultobj = 0;
    6711           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6712           0 :   lldb::SBListener *arg2 = 0 ;
    6713           0 :   void *argp1 = 0 ;
    6714           0 :   int res1 = 0 ;
    6715           0 :   void *argp2 = 0 ;
    6716           0 :   int res2 = 0 ;
    6717           0 :   PyObject * obj0 = 0 ;
    6718           0 :   PyObject * obj1 = 0 ;
    6719             :   
    6720           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetListener",&obj0,&obj1)) SWIG_fail;
    6721           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6722           0 :   if (!SWIG_IsOK(res1)) {
    6723           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetListener" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6724             :   }
    6725           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6726           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBListener,  0 );
    6727           0 :   if (!SWIG_IsOK(res2)) {
    6728           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
    6729             :   }
    6730           0 :   if (!argp2) {
    6731           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAttachInfo_SetListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
    6732             :   }
    6733           0 :   arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
    6734             :   {
    6735           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6736           0 :     (arg1)->SetListener(*arg2);
    6737           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6738             :   }
    6739           0 :   resultobj = SWIG_Py_Void();
    6740           0 :   return resultobj;
    6741           0 : fail:
    6742             :   return NULL;
    6743             : }
    6744             : 
    6745             : 
    6746           0 : SWIGINTERN PyObject *_wrap_delete_SBAttachInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6747           0 :   PyObject *resultobj = 0;
    6748           0 :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6749           0 :   void *argp1 = 0 ;
    6750           0 :   int res1 = 0 ;
    6751           0 :   PyObject * obj0 = 0 ;
    6752             :   
    6753           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBAttachInfo",&obj0)) SWIG_fail;
    6754           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_DISOWN |  0 );
    6755           0 :   if (!SWIG_IsOK(res1)) {
    6756           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBAttachInfo" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6757             :   }
    6758           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6759             :   {
    6760           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6761           0 :     delete arg1;
    6762           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6763             :   }
    6764           0 :   resultobj = SWIG_Py_Void();
    6765           0 :   return resultobj;
    6766           0 : fail:
    6767             :   return NULL;
    6768             : }
    6769             : 
    6770             : 
    6771         605 : SWIGINTERN PyObject *SBAttachInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6772             :   PyObject *obj;
    6773         605 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    6774        1210 :   SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBAttachInfo, SWIG_NewClientData(obj));
    6775         605 :   return SWIG_Py_Void();
    6776             : }
    6777             : 
    6778           1 : SWIGINTERN PyObject *_wrap_new_SBBlock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6779           1 :   PyObject *resultobj = 0;
    6780           1 :   lldb::SBBlock *result = 0 ;
    6781             :   
    6782           1 :   if (!PyArg_ParseTuple(args,(char *)":new_SBBlock")) SWIG_fail;
    6783             :   {
    6784           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6785           1 :     result = (lldb::SBBlock *)new lldb::SBBlock();
    6786           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6787             :   }
    6788           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_NEW |  0 );
    6789             :   return resultobj;
    6790           1 : fail:
    6791             :   return NULL;
    6792             : }
    6793             : 
    6794             : 
    6795           0 : SWIGINTERN PyObject *_wrap_new_SBBlock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6796           0 :   PyObject *resultobj = 0;
    6797           0 :   lldb::SBBlock *arg1 = 0 ;
    6798           0 :   void *argp1 = 0 ;
    6799           0 :   int res1 = 0 ;
    6800           0 :   PyObject * obj0 = 0 ;
    6801           0 :   lldb::SBBlock *result = 0 ;
    6802             :   
    6803           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBBlock",&obj0)) SWIG_fail;
    6804           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBBlock,  0  | 0);
    6805           0 :   if (!SWIG_IsOK(res1)) {
    6806           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBlock" "', argument " "1"" of type '" "lldb::SBBlock const &""'"); 
    6807             :   }
    6808           0 :   if (!argp1) {
    6809           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBBlock" "', argument " "1"" of type '" "lldb::SBBlock const &""'"); 
    6810             :   }
    6811           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6812             :   {
    6813           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6814           0 :     result = (lldb::SBBlock *)new lldb::SBBlock((lldb::SBBlock const &)*arg1);
    6815           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6816             :   }
    6817           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_NEW |  0 );
    6818             :   return resultobj;
    6819             : fail:
    6820             :   return NULL;
    6821             : }
    6822             : 
    6823             : 
    6824           1 : SWIGINTERN PyObject *_wrap_new_SBBlock(PyObject *self, PyObject *args) {
    6825             :   Py_ssize_t argc;
    6826           1 :   PyObject *argv[2] = {
    6827             :     0
    6828             :   };
    6829             :   Py_ssize_t ii;
    6830             :   
    6831           1 :   if (!PyTuple_Check(args)) SWIG_fail;
    6832           1 :   argc = args ? PyObject_Length(args) : 0;
    6833           1 :   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    6834           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    6835             :   }
    6836           1 :   if (argc == 0) {
    6837           1 :     return _wrap_new_SBBlock__SWIG_0(self, args);
    6838             :   }
    6839           0 :   if (argc == 1) {
    6840             :     int _v;
    6841           0 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBBlock, 0);
    6842           0 :     _v = SWIG_CheckState(res);
    6843             :     if (_v) {
    6844           0 :       return _wrap_new_SBBlock__SWIG_1(self, args);
    6845             :     }
    6846             :   }
    6847             :   
    6848           0 : fail:
    6849           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SBBlock'.\n"
    6850             :     "  Possible C/C++ prototypes are:\n"
    6851             :     "    lldb::SBBlock::SBBlock()\n"
    6852             :     "    lldb::SBBlock::SBBlock(lldb::SBBlock const &)\n");
    6853           0 :   return 0;
    6854             : }
    6855             : 
    6856             : 
    6857          10 : SWIGINTERN PyObject *_wrap_delete_SBBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6858          10 :   PyObject *resultobj = 0;
    6859          10 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6860          10 :   void *argp1 = 0 ;
    6861          10 :   int res1 = 0 ;
    6862          10 :   PyObject * obj0 = 0 ;
    6863             :   
    6864          10 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBBlock",&obj0)) SWIG_fail;
    6865          10 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_DISOWN |  0 );
    6866          10 :   if (!SWIG_IsOK(res1)) {
    6867           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBlock" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    6868             :   }
    6869          10 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6870             :   {
    6871          20 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6872          10 :     delete arg1;
    6873          10 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6874             :   }
    6875          10 :   resultobj = SWIG_Py_Void();
    6876          10 :   return resultobj;
    6877           0 : fail:
    6878             :   return NULL;
    6879             : }
    6880             : 
    6881             : 
    6882           1 : SWIGINTERN PyObject *_wrap_SBBlock_IsInlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6883           1 :   PyObject *resultobj = 0;
    6884           1 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6885           1 :   void *argp1 = 0 ;
    6886           1 :   int res1 = 0 ;
    6887           1 :   PyObject * obj0 = 0 ;
    6888             :   bool result;
    6889             :   
    6890           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_IsInlined",&obj0)) SWIG_fail;
    6891           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    6892           1 :   if (!SWIG_IsOK(res1)) {
    6893           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_IsInlined" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    6894             :   }
    6895           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6896             :   {
    6897           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6898           1 :     result = (bool)((lldb::SBBlock const *)arg1)->IsInlined();
    6899           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6900             :   }
    6901           1 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6902           1 :   return resultobj;
    6903           0 : fail:
    6904             :   return NULL;
    6905             : }
    6906             : 
    6907             : 
    6908           1 : SWIGINTERN PyObject *_wrap_SBBlock_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6909           1 :   PyObject *resultobj = 0;
    6910           1 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6911           1 :   void *argp1 = 0 ;
    6912           1 :   int res1 = 0 ;
    6913           1 :   PyObject * obj0 = 0 ;
    6914             :   bool result;
    6915             :   
    6916           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_IsValid",&obj0)) SWIG_fail;
    6917           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    6918           1 :   if (!SWIG_IsOK(res1)) {
    6919           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_IsValid" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    6920             :   }
    6921           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6922             :   {
    6923           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6924           1 :     result = (bool)((lldb::SBBlock const *)arg1)->IsValid();
    6925           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6926             :   }
    6927           1 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6928           1 :   return resultobj;
    6929           0 : fail:
    6930             :   return NULL;
    6931             : }
    6932             : 
    6933             : 
    6934           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6935           1 :   PyObject *resultobj = 0;
    6936           1 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6937           1 :   void *argp1 = 0 ;
    6938           1 :   int res1 = 0 ;
    6939           1 :   PyObject * obj0 = 0 ;
    6940           1 :   char *result = 0 ;
    6941             :   
    6942           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetInlinedName",&obj0)) SWIG_fail;
    6943           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    6944           1 :   if (!SWIG_IsOK(res1)) {
    6945           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedName" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    6946             :   }
    6947           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6948             :   {
    6949           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6950           1 :     result = (char *)((lldb::SBBlock const *)arg1)->GetInlinedName();
    6951           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6952             :   }
    6953           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    6954           1 :   return resultobj;
    6955           0 : fail:
    6956             :   return NULL;
    6957             : }
    6958             : 
    6959             : 
    6960           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6961           1 :   PyObject *resultobj = 0;
    6962           1 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6963           1 :   void *argp1 = 0 ;
    6964           1 :   int res1 = 0 ;
    6965           1 :   PyObject * obj0 = 0 ;
    6966           2 :   lldb::SBFileSpec result;
    6967             :   
    6968           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetInlinedCallSiteFile",&obj0)) SWIG_fail;
    6969           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    6970           1 :   if (!SWIG_IsOK(res1)) {
    6971           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedCallSiteFile" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    6972             :   }
    6973           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6974             :   {
    6975           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6976           1 :     result = ((lldb::SBBlock const *)arg1)->GetInlinedCallSiteFile();
    6977           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    6978             :   }
    6979           1 :   resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(static_cast< const lldb::SBFileSpec& >(result))), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
    6980           1 :   return resultobj;
    6981           0 : fail:
    6982             :   return NULL;
    6983             : }
    6984             : 
    6985             : 
    6986           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6987           1 :   PyObject *resultobj = 0;
    6988           1 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6989           1 :   void *argp1 = 0 ;
    6990           1 :   int res1 = 0 ;
    6991           1 :   PyObject * obj0 = 0 ;
    6992             :   uint32_t result;
    6993             :   
    6994           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetInlinedCallSiteLine",&obj0)) SWIG_fail;
    6995           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    6996           1 :   if (!SWIG_IsOK(res1)) {
    6997           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedCallSiteLine" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    6998             :   }
    6999           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7000             :   {
    7001           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7002           1 :     result = (uint32_t)((lldb::SBBlock const *)arg1)->GetInlinedCallSiteLine();
    7003           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7004             :   }
    7005           1 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    7006           1 :   return resultobj;
    7007           0 : fail:
    7008             :   return NULL;
    7009             : }
    7010             : 
    7011             : 
    7012           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7013           1 :   PyObject *resultobj = 0;
    7014           1 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7015           1 :   void *argp1 = 0 ;
    7016           1 :   int res1 = 0 ;
    7017           1 :   PyObject * obj0 = 0 ;
    7018             :   uint32_t result;
    7019             :   
    7020           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetInlinedCallSiteColumn",&obj0)) SWIG_fail;
    7021           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7022           1 :   if (!SWIG_IsOK(res1)) {
    7023           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedCallSiteColumn" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    7024             :   }
    7025           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7026             :   {
    7027           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7028           1 :     result = (uint32_t)((lldb::SBBlock const *)arg1)->GetInlinedCallSiteColumn();
    7029           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7030             :   }
    7031           1 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    7032           1 :   return resultobj;
    7033           0 : fail:
    7034             :   return NULL;
    7035             : }
    7036             : 
    7037             : 
    7038           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7039           1 :   PyObject *resultobj = 0;
    7040           1 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7041           1 :   void *argp1 = 0 ;
    7042           1 :   int res1 = 0 ;
    7043           1 :   PyObject * obj0 = 0 ;
    7044           2 :   lldb::SBBlock result;
    7045             :   
    7046           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetParent",&obj0)) SWIG_fail;
    7047           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7048           1 :   if (!SWIG_IsOK(res1)) {
    7049           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetParent" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7050             :   }
    7051           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7052             :   {
    7053           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7054           1 :     result = (arg1)->GetParent();
    7055           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7056             :   }
    7057           1 :   resultobj = SWIG_NewPointerObj((new lldb::SBBlock(static_cast< const lldb::SBBlock& >(result))), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
    7058           1 :   return resultobj;
    7059           0 : fail:
    7060             :   return NULL;
    7061             : }
    7062             : 
    7063             : 
    7064           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetContainingInlinedBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7065           0 :   PyObject *resultobj = 0;
    7066           0 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7067           0 :   void *argp1 = 0 ;
    7068           0 :   int res1 = 0 ;
    7069           0 :   PyObject * obj0 = 0 ;
    7070           0 :   lldb::SBBlock result;
    7071             :   
    7072           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetContainingInlinedBlock",&obj0)) SWIG_fail;
    7073           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7074           0 :   if (!SWIG_IsOK(res1)) {
    7075           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetContainingInlinedBlock" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7076             :   }
    7077           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7078             :   {
    7079           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7080           0 :     result = (arg1)->GetContainingInlinedBlock();
    7081           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7082             :   }
    7083           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBBlock(static_cast< const lldb::SBBlock& >(result))), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
    7084           0 :   return resultobj;
    7085           0 : fail:
    7086             :   return NULL;
    7087             : }
    7088             : 
    7089             : 
    7090           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetSibling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7091           1 :   PyObject *resultobj = 0;
    7092           1 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7093           1 :   void *argp1 = 0 ;
    7094           1 :   int res1 = 0 ;
    7095           1 :   PyObject * obj0 = 0 ;
    7096           2 :   lldb::SBBlock result;
    7097             :   
    7098           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetSibling",&obj0)) SWIG_fail;
    7099           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7100           1 :   if (!SWIG_IsOK(res1)) {
    7101           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetSibling" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7102             :   }
    7103           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7104             :   {
    7105           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7106           1 :     result = (arg1)->GetSibling();
    7107           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7108             :   }
    7109           1 :   resultobj = SWIG_NewPointerObj((new lldb::SBBlock(static_cast< const lldb::SBBlock& >(result))), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
    7110           1 :   return resultobj;
    7111           0 : fail:
    7112             :   return NULL;
    7113             : }
    7114             : 
    7115             : 
    7116           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetFirstChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7117           1 :   PyObject *resultobj = 0;
    7118           1 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7119           1 :   void *argp1 = 0 ;
    7120           1 :   int res1 = 0 ;
    7121           1 :   PyObject * obj0 = 0 ;
    7122           2 :   lldb::SBBlock result;
    7123             :   
    7124           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetFirstChild",&obj0)) SWIG_fail;
    7125           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7126           1 :   if (!SWIG_IsOK(res1)) {
    7127           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetFirstChild" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7128             :   }
    7129           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7130             :   {
    7131           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7132           1 :     result = (arg1)->GetFirstChild();
    7133           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7134             :   }
    7135           1 :   resultobj = SWIG_NewPointerObj((new lldb::SBBlock(static_cast< const lldb::SBBlock& >(result))), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
    7136           1 :   return resultobj;
    7137           0 : fail:
    7138             :   return NULL;
    7139             : }
    7140             : 
    7141             : 
    7142           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetNumRanges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7143           0 :   PyObject *resultobj = 0;
    7144           0 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7145           0 :   void *argp1 = 0 ;
    7146           0 :   int res1 = 0 ;
    7147           0 :   PyObject * obj0 = 0 ;
    7148             :   uint32_t result;
    7149             :   
    7150           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetNumRanges",&obj0)) SWIG_fail;
    7151           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7152           0 :   if (!SWIG_IsOK(res1)) {
    7153           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetNumRanges" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7154             :   }
    7155           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7156             :   {
    7157           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7158           0 :     result = (uint32_t)(arg1)->GetNumRanges();
    7159           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7160             :   }
    7161           0 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    7162           0 :   return resultobj;
    7163           0 : fail:
    7164             :   return NULL;
    7165             : }
    7166             : 
    7167             : 
    7168           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetRangeStartAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7169           0 :   PyObject *resultobj = 0;
    7170           0 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7171             :   uint32_t arg2 ;
    7172           0 :   void *argp1 = 0 ;
    7173           0 :   int res1 = 0 ;
    7174             :   unsigned int val2 ;
    7175           0 :   int ecode2 = 0 ;
    7176           0 :   PyObject * obj0 = 0 ;
    7177           0 :   PyObject * obj1 = 0 ;
    7178           0 :   lldb::SBAddress result;
    7179             :   
    7180           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBlock_GetRangeStartAddress",&obj0,&obj1)) SWIG_fail;
    7181           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7182           0 :   if (!SWIG_IsOK(res1)) {
    7183           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetRangeStartAddress" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7184             :   }
    7185           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7186           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    7187           0 :   if (!SWIG_IsOK(ecode2)) {
    7188           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBlock_GetRangeStartAddress" "', argument " "2"" of type '" "uint32_t""'");
    7189             :   } 
    7190           0 :   arg2 = static_cast< uint32_t >(val2);
    7191             :   {
    7192           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7193           0 :     result = (arg1)->GetRangeStartAddress(arg2);
    7194           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7195             :   }
    7196           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBAddress(static_cast< const lldb::SBAddress& >(result))), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
    7197           0 :   return resultobj;
    7198           0 : fail:
    7199             :   return NULL;
    7200             : }
    7201             : 
    7202             : 
    7203           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetRangeEndAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7204           0 :   PyObject *resultobj = 0;
    7205           0 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7206             :   uint32_t arg2 ;
    7207           0 :   void *argp1 = 0 ;
    7208           0 :   int res1 = 0 ;
    7209             :   unsigned int val2 ;
    7210           0 :   int ecode2 = 0 ;
    7211           0 :   PyObject * obj0 = 0 ;
    7212           0 :   PyObject * obj1 = 0 ;
    7213           0 :   lldb::SBAddress result;
    7214             :   
    7215           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBlock_GetRangeEndAddress",&obj0,&obj1)) SWIG_fail;
    7216           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7217           0 :   if (!SWIG_IsOK(res1)) {
    7218           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetRangeEndAddress" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7219             :   }
    7220           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7221           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    7222           0 :   if (!SWIG_IsOK(ecode2)) {
    7223           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBlock_GetRangeEndAddress" "', argument " "2"" of type '" "uint32_t""'");
    7224             :   } 
    7225           0 :   arg2 = static_cast< uint32_t >(val2);
    7226             :   {
    7227           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7228           0 :     result = (arg1)->GetRangeEndAddress(arg2);
    7229           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7230             :   }
    7231           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBAddress(static_cast< const lldb::SBAddress& >(result))), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
    7232           0 :   return resultobj;
    7233           0 : fail:
    7234             :   return NULL;
    7235             : }
    7236             : 
    7237             : 
    7238           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetRangeIndexForBlockAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7239           0 :   PyObject *resultobj = 0;
    7240           0 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7241           0 :   lldb::SBAddress arg2 ;
    7242           0 :   void *argp1 = 0 ;
    7243           0 :   int res1 = 0 ;
    7244             :   void *argp2 ;
    7245           0 :   int res2 = 0 ;
    7246           0 :   PyObject * obj0 = 0 ;
    7247           0 :   PyObject * obj1 = 0 ;
    7248             :   uint32_t result;
    7249             :   
    7250           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBlock_GetRangeIndexForBlockAddress",&obj0,&obj1)) SWIG_fail;
    7251           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7252           0 :   if (!SWIG_IsOK(res1)) {
    7253           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetRangeIndexForBlockAddress" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7254             :   }
    7255           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7256             :   {
    7257           0 :     res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    7258           0 :     if (!SWIG_IsOK(res2)) {
    7259           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetRangeIndexForBlockAddress" "', argument " "2"" of type '" "lldb::SBAddress""'"); 
    7260             :     }  
    7261           0 :     if (!argp2) {
    7262           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBlock_GetRangeIndexForBlockAddress" "', argument " "2"" of type '" "lldb::SBAddress""'");
    7263             :     } else {
    7264           0 :       lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
    7265           0 :       arg2 = *temp;
    7266           0 :       if (SWIG_IsNewObj(res2)) delete temp;
    7267             :     }
    7268             :   }
    7269             :   {
    7270           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7271           0 :     result = (uint32_t)(arg1)->GetRangeIndexForBlockAddress(arg2);
    7272           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7273             :   }
    7274           0 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    7275           0 :   return resultobj;
    7276           0 : fail:
    7277             :   return NULL;
    7278             : }
    7279             : 
    7280             : 
    7281           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7282           1 :   PyObject *resultobj = 0;
    7283           1 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7284           1 :   lldb::SBStream *arg2 = 0 ;
    7285           1 :   void *argp1 = 0 ;
    7286           1 :   int res1 = 0 ;
    7287           1 :   void *argp2 = 0 ;
    7288           1 :   int res2 = 0 ;
    7289           1 :   PyObject * obj0 = 0 ;
    7290           1 :   PyObject * obj1 = 0 ;
    7291             :   bool result;
    7292             :   
    7293           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBlock_GetDescription",&obj0,&obj1)) SWIG_fail;
    7294           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7295           1 :   if (!SWIG_IsOK(res1)) {
    7296           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetDescription" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7297             :   }
    7298           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7299           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
    7300           1 :   if (!SWIG_IsOK(res2)) {
    7301           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    7302             :   }
    7303           1 :   if (!argp2) {
    7304           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBlock_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    7305             :   }
    7306           1 :   arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
    7307             :   {
    7308           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7309           1 :     result = (bool)(arg1)->GetDescription(*arg2);
    7310           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7311             :   }
    7312           1 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7313           1 :   return resultobj;
    7314           0 : fail:
    7315             :   return NULL;
    7316             : }
    7317             : 
    7318             : 
    7319           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetVariables__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7320           0 :   PyObject *resultobj = 0;
    7321           0 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7322           0 :   lldb::SBFrame *arg2 = 0 ;
    7323             :   bool arg3 ;
    7324             :   bool arg4 ;
    7325             :   bool arg5 ;
    7326             :   lldb::DynamicValueType arg6 ;
    7327           0 :   void *argp1 = 0 ;
    7328           0 :   int res1 = 0 ;
    7329           0 :   void *argp2 = 0 ;
    7330           0 :   int res2 = 0 ;
    7331             :   bool val3 ;
    7332           0 :   int ecode3 = 0 ;
    7333             :   bool val4 ;
    7334           0 :   int ecode4 = 0 ;
    7335             :   bool val5 ;
    7336           0 :   int ecode5 = 0 ;
    7337             :   int val6 ;
    7338           0 :   int ecode6 = 0 ;
    7339           0 :   PyObject * obj0 = 0 ;
    7340           0 :   PyObject * obj1 = 0 ;
    7341           0 :   PyObject * obj2 = 0 ;
    7342           0 :   PyObject * obj3 = 0 ;
    7343           0 :   PyObject * obj4 = 0 ;
    7344           0 :   PyObject * obj5 = 0 ;
    7345           0 :   lldb::SBValueList result;
    7346             :   
    7347           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SBBlock_GetVariables",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
    7348           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7349           0 :   if (!SWIG_IsOK(res1)) {
    7350           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetVariables" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7351             :   }
    7352           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7353           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBFrame,  0 );
    7354           0 :   if (!SWIG_IsOK(res2)) {
    7355           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
    7356             :   }
    7357           0 :   if (!argp2) {
    7358           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
    7359             :   }
    7360           0 :   arg2 = reinterpret_cast< lldb::SBFrame * >(argp2);
    7361           0 :   ecode3 = SWIG_AsVal_bool(obj2, &val3);
    7362             :   if (!SWIG_IsOK(ecode3)) {
    7363           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBlock_GetVariables" "', argument " "3"" of type '" "bool""'");
    7364             :   } 
    7365           0 :   arg3 = static_cast< bool >(val3);
    7366           0 :   ecode4 = SWIG_AsVal_bool(obj3, &val4);
    7367             :   if (!SWIG_IsOK(ecode4)) {
    7368           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBBlock_GetVariables" "', argument " "4"" of type '" "bool""'");
    7369             :   } 
    7370           0 :   arg4 = static_cast< bool >(val4);
    7371           0 :   ecode5 = SWIG_AsVal_bool(obj4, &val5);
    7372             :   if (!SWIG_IsOK(ecode5)) {
    7373           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBBlock_GetVariables" "', argument " "5"" of type '" "bool""'");
    7374             :   } 
    7375           0 :   arg5 = static_cast< bool >(val5);
    7376           0 :   ecode6 = SWIG_AsVal_int(obj5, &val6);
    7377           0 :   if (!SWIG_IsOK(ecode6)) {
    7378           0 :     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBBlock_GetVariables" "', argument " "6"" of type '" "lldb::DynamicValueType""'");
    7379             :   } 
    7380           0 :   arg6 = static_cast< lldb::DynamicValueType >(val6);
    7381             :   {
    7382           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7383           0 :     result = (arg1)->GetVariables(*arg2,arg3,arg4,arg5,arg6);
    7384           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7385             :   }
    7386           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBValueList(static_cast< const lldb::SBValueList& >(result))), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
    7387             :   return resultobj;
    7388             : fail:
    7389             :   return NULL;
    7390             : }
    7391             : 
    7392             : 
    7393           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetVariables__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7394           0 :   PyObject *resultobj = 0;
    7395           0 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7396           0 :   lldb::SBTarget *arg2 = 0 ;
    7397             :   bool arg3 ;
    7398             :   bool arg4 ;
    7399             :   bool arg5 ;
    7400           0 :   void *argp1 = 0 ;
    7401           0 :   int res1 = 0 ;
    7402           0 :   void *argp2 = 0 ;
    7403           0 :   int res2 = 0 ;
    7404             :   bool val3 ;
    7405           0 :   int ecode3 = 0 ;
    7406             :   bool val4 ;
    7407           0 :   int ecode4 = 0 ;
    7408             :   bool val5 ;
    7409           0 :   int ecode5 = 0 ;
    7410           0 :   PyObject * obj0 = 0 ;
    7411           0 :   PyObject * obj1 = 0 ;
    7412           0 :   PyObject * obj2 = 0 ;
    7413           0 :   PyObject * obj3 = 0 ;
    7414           0 :   PyObject * obj4 = 0 ;
    7415           0 :   lldb::SBValueList result;
    7416             :   
    7417           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOOO:SBBlock_GetVariables",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
    7418           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7419           0 :   if (!SWIG_IsOK(res1)) {
    7420           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetVariables" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7421             :   }
    7422           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7423           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBTarget,  0 );
    7424           0 :   if (!SWIG_IsOK(res2)) {
    7425           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
    7426             :   }
    7427           0 :   if (!argp2) {
    7428           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
    7429             :   }
    7430           0 :   arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
    7431           0 :   ecode3 = SWIG_AsVal_bool(obj2, &val3);
    7432             :   if (!SWIG_IsOK(ecode3)) {
    7433           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBlock_GetVariables" "', argument " "3"" of type '" "bool""'");
    7434             :   } 
    7435           0 :   arg3 = static_cast< bool >(val3);
    7436           0 :   ecode4 = SWIG_AsVal_bool(obj3, &val4);
    7437             :   if (!SWIG_IsOK(ecode4)) {
    7438           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBBlock_GetVariables" "', argument " "4"" of type '" "bool""'");
    7439             :   } 
    7440           0 :   arg4 = static_cast< bool >(val4);
    7441           0 :   ecode5 = SWIG_AsVal_bool(obj4, &val5);
    7442             :   if (!SWIG_IsOK(ecode5)) {
    7443           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBBlock_GetVariables" "', argument " "5"" of type '" "bool""'");
    7444             :   } 
    7445           0 :   arg5 = static_cast< bool >(val5);
    7446             :   {
    7447           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7448           0 :     result = (arg1)->GetVariables(*arg2,arg3,arg4,arg5);
    7449           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7450             :   }
    7451           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBValueList(static_cast< const lldb::SBValueList& >(result))), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
    7452             :   return resultobj;
    7453             : fail:
    7454             :   return NULL;
    7455             : }
    7456             : 
    7457             : 
    7458           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetVariables(PyObject *self, PyObject *args) {
    7459             :   Py_ssize_t argc;
    7460           0 :   PyObject *argv[7] = {
    7461             :     0
    7462             :   };
    7463             :   Py_ssize_t ii;
    7464             :   
    7465           0 :   if (!PyTuple_Check(args)) SWIG_fail;
    7466           0 :   argc = args ? PyObject_Length(args) : 0;
    7467           0 :   for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    7468           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    7469             :   }
    7470           0 :   if (argc == 5) {
    7471             :     int _v;
    7472           0 :     void *vptr = 0;
    7473           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBlock, 0);
    7474           0 :     _v = SWIG_CheckState(res);
    7475             :     if (_v) {
    7476           0 :       void *vptr = 0;
    7477           0 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    7478           0 :       _v = SWIG_CheckState(res);
    7479             :       if (_v) {
    7480             :         {
    7481           0 :           int res = SWIG_AsVal_bool(argv[2], NULL);
    7482           0 :           _v = SWIG_CheckState(res);
    7483             :         }
    7484             :         if (_v) {
    7485             :           {
    7486           0 :             int res = SWIG_AsVal_bool(argv[3], NULL);
    7487           0 :             _v = SWIG_CheckState(res);
    7488             :           }
    7489             :           if (_v) {
    7490             :             {
    7491           0 :               int res = SWIG_AsVal_bool(argv[4], NULL);
    7492           0 :               _v = SWIG_CheckState(res);
    7493             :             }
    7494             :             if (_v) {
    7495           0 :               return _wrap_SBBlock_GetVariables__SWIG_1(self, args);
    7496             :             }
    7497             :           }
    7498             :         }
    7499             :       }
    7500             :     }
    7501             :   }
    7502           0 :   if (argc == 6) {
    7503             :     int _v;
    7504           0 :     void *vptr = 0;
    7505           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBlock, 0);
    7506           0 :     _v = SWIG_CheckState(res);
    7507             :     if (_v) {
    7508           0 :       void *vptr = 0;
    7509           0 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    7510           0 :       _v = SWIG_CheckState(res);
    7511             :       if (_v) {
    7512             :         {
    7513           0 :           int res = SWIG_AsVal_bool(argv[2], NULL);
    7514           0 :           _v = SWIG_CheckState(res);
    7515             :         }
    7516             :         if (_v) {
    7517             :           {
    7518           0 :             int res = SWIG_AsVal_bool(argv[3], NULL);
    7519           0 :             _v = SWIG_CheckState(res);
    7520             :           }
    7521             :           if (_v) {
    7522             :             {
    7523           0 :               int res = SWIG_AsVal_bool(argv[4], NULL);
    7524           0 :               _v = SWIG_CheckState(res);
    7525             :             }
    7526             :             if (_v) {
    7527             :               {
    7528           0 :                 int res = SWIG_AsVal_int(argv[5], NULL);
    7529           0 :                 _v = SWIG_CheckState(res);
    7530             :               }
    7531             :               if (_v) {
    7532           0 :                 return _wrap_SBBlock_GetVariables__SWIG_0(self, args);
    7533             :               }
    7534             :             }
    7535             :           }
    7536             :         }
    7537             :       }
    7538             :     }
    7539             :   }
    7540             :   
    7541           0 : fail:
    7542           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SBBlock_GetVariables'.\n"
    7543             :     "  Possible C/C++ prototypes are:\n"
    7544             :     "    lldb::SBBlock::GetVariables(lldb::SBFrame &,bool,bool,bool,lldb::DynamicValueType)\n"
    7545             :     "    lldb::SBBlock::GetVariables(lldb::SBTarget &,bool,bool,bool)\n");
    7546           0 :   return 0;
    7547             : }
    7548             : 
    7549             : 
    7550           0 : SWIGINTERN PyObject *_wrap_SBBlock___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7551           0 :   PyObject *resultobj = 0;
    7552           0 :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7553           0 :   void *argp1 = 0 ;
    7554           0 :   int res1 = 0 ;
    7555           0 :   PyObject * obj0 = 0 ;
    7556           0 :   PyObject *result = 0 ;
    7557             :   
    7558           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock___str__",&obj0)) SWIG_fail;
    7559           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7560           0 :   if (!SWIG_IsOK(res1)) {
    7561           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock___str__" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7562             :   }
    7563           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7564             :   {
    7565           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7566           0 :     result = (PyObject *)lldb_SBBlock___str__(arg1);
    7567           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7568             :   }
    7569           0 :   resultobj = result;
    7570           0 :   return resultobj;
    7571           0 : fail:
    7572             :   return NULL;
    7573             : }
    7574             : 
    7575             : 
    7576         605 : SWIGINTERN PyObject *SBBlock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7577             :   PyObject *obj;
    7578         605 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    7579        1210 :   SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBlock, SWIG_NewClientData(obj));
    7580         605 :   return SWIG_Py_Void();
    7581             : }
    7582             : 
    7583           1 : SWIGINTERN PyObject *_wrap_new_SBBreakpoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7584           1 :   PyObject *resultobj = 0;
    7585           1 :   lldb::SBBreakpoint *result = 0 ;
    7586             :   
    7587           1 :   if (!PyArg_ParseTuple(args,(char *)":new_SBBreakpoint")) SWIG_fail;
    7588             :   {
    7589           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7590           1 :     result = (lldb::SBBreakpoint *)new lldb::SBBreakpoint();
    7591           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7592             :   }
    7593           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NEW |  0 );
    7594             :   return resultobj;
    7595           1 : fail:
    7596             :   return NULL;
    7597             : }
    7598             : 
    7599             : 
    7600           0 : SWIGINTERN PyObject *_wrap_new_SBBreakpoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7601           0 :   PyObject *resultobj = 0;
    7602           0 :   lldb::SBBreakpoint *arg1 = 0 ;
    7603           0 :   void *argp1 = 0 ;
    7604           0 :   int res1 = 0 ;
    7605           0 :   PyObject * obj0 = 0 ;
    7606           0 :   lldb::SBBreakpoint *result = 0 ;
    7607             :   
    7608           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBBreakpoint",&obj0)) SWIG_fail;
    7609           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
    7610           0 :   if (!SWIG_IsOK(res1)) {
    7611           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpoint" "', argument " "1"" of type '" "lldb::SBBreakpoint const &""'"); 
    7612             :   }
    7613           0 :   if (!argp1) {
    7614           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBBreakpoint" "', argument " "1"" of type '" "lldb::SBBreakpoint const &""'"); 
    7615             :   }
    7616           0 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7617             :   {
    7618           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7619           0 :     result = (lldb::SBBreakpoint *)new lldb::SBBreakpoint((lldb::SBBreakpoint const &)*arg1);
    7620           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7621             :   }
    7622           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NEW |  0 );
    7623             :   return resultobj;
    7624             : fail:
    7625             :   return NULL;
    7626             : }
    7627             : 
    7628             : 
    7629           1 : SWIGINTERN PyObject *_wrap_new_SBBreakpoint(PyObject *self, PyObject *args) {
    7630             :   Py_ssize_t argc;
    7631           1 :   PyObject *argv[2] = {
    7632             :     0
    7633             :   };
    7634             :   Py_ssize_t ii;
    7635             :   
    7636           1 :   if (!PyTuple_Check(args)) SWIG_fail;
    7637           1 :   argc = args ? PyObject_Length(args) : 0;
    7638           1 :   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    7639           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    7640             :   }
    7641           1 :   if (argc == 0) {
    7642           1 :     return _wrap_new_SBBreakpoint__SWIG_0(self, args);
    7643             :   }
    7644           0 :   if (argc == 1) {
    7645             :     int _v;
    7646           0 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBBreakpoint, 0);
    7647           0 :     _v = SWIG_CheckState(res);
    7648             :     if (_v) {
    7649           0 :       return _wrap_new_SBBreakpoint__SWIG_1(self, args);
    7650             :     }
    7651             :   }
    7652             :   
    7653           0 : fail:
    7654           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SBBreakpoint'.\n"
    7655             :     "  Possible C/C++ prototypes are:\n"
    7656             :     "    lldb::SBBreakpoint::SBBreakpoint()\n"
    7657             :     "    lldb::SBBreakpoint::SBBreakpoint(lldb::SBBreakpoint const &)\n");
    7658           0 :   return 0;
    7659             : }
    7660             : 
    7661             : 
    7662         569 : SWIGINTERN PyObject *_wrap_delete_SBBreakpoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7663         569 :   PyObject *resultobj = 0;
    7664         569 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7665         569 :   void *argp1 = 0 ;
    7666         569 :   int res1 = 0 ;
    7667         569 :   PyObject * obj0 = 0 ;
    7668             :   
    7669         569 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBBreakpoint",&obj0)) SWIG_fail;
    7670         569 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_DISOWN |  0 );
    7671         569 :   if (!SWIG_IsOK(res1)) {
    7672           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBreakpoint" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7673             :   }
    7674         569 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7675             :   {
    7676        1138 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7677         569 :     delete arg1;
    7678         569 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7679             :   }
    7680         569 :   resultobj = SWIG_Py_Void();
    7681         569 :   return resultobj;
    7682           0 : fail:
    7683             :   return NULL;
    7684             : }
    7685             : 
    7686             : 
    7687         136 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7688         136 :   PyObject *resultobj = 0;
    7689         136 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7690         136 :   void *argp1 = 0 ;
    7691         136 :   int res1 = 0 ;
    7692         136 :   PyObject * obj0 = 0 ;
    7693             :   lldb::break_id_t result;
    7694             :   
    7695         136 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetID",&obj0)) SWIG_fail;
    7696         136 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7697         136 :   if (!SWIG_IsOK(res1)) {
    7698           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetID" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    7699             :   }
    7700         136 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7701             :   {
    7702         272 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7703         136 :     result = (lldb::break_id_t)((lldb::SBBreakpoint const *)arg1)->GetID();
    7704         136 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7705             :   }
    7706         136 :   resultobj = SWIG_From_int(static_cast< int >(result));
    7707         136 :   return resultobj;
    7708           0 : fail:
    7709             :   return NULL;
    7710             : }
    7711             : 
    7712             : 
    7713         325 : SWIGINTERN PyObject *_wrap_SBBreakpoint_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7714         325 :   PyObject *resultobj = 0;
    7715         325 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7716         325 :   void *argp1 = 0 ;
    7717         325 :   int res1 = 0 ;
    7718         325 :   PyObject * obj0 = 0 ;
    7719             :   bool result;
    7720             :   
    7721         325 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_IsValid",&obj0)) SWIG_fail;
    7722         325 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7723         325 :   if (!SWIG_IsOK(res1)) {
    7724           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsValid" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    7725             :   }
    7726         325 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7727             :   {
    7728         650 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7729         325 :     result = (bool)((lldb::SBBreakpoint const *)arg1)->IsValid();
    7730         325 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7731             :   }
    7732         325 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7733         325 :   return resultobj;
    7734           0 : fail:
    7735             :   return NULL;
    7736             : }
    7737             : 
    7738             : 
    7739           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_ClearAllBreakpointSites(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7740           2 :   PyObject *resultobj = 0;
    7741           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7742           2 :   void *argp1 = 0 ;
    7743           2 :   int res1 = 0 ;
    7744           2 :   PyObject * obj0 = 0 ;
    7745             :   
    7746           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_ClearAllBreakpointSites",&obj0)) SWIG_fail;
    7747           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7748           2 :   if (!SWIG_IsOK(res1)) {
    7749           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_ClearAllBreakpointSites" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7750             :   }
    7751           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7752             :   {
    7753           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7754           2 :     (arg1)->ClearAllBreakpointSites();
    7755           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7756             :   }
    7757           2 :   resultobj = SWIG_Py_Void();
    7758           2 :   return resultobj;
    7759           0 : fail:
    7760             :   return NULL;
    7761             : }
    7762             : 
    7763             : 
    7764           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationByAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7765           2 :   PyObject *resultobj = 0;
    7766           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7767             :   lldb::addr_t arg2 ;
    7768           2 :   void *argp1 = 0 ;
    7769           2 :   int res1 = 0 ;
    7770             :   unsigned long long val2 ;
    7771           2 :   int ecode2 = 0 ;
    7772           2 :   PyObject * obj0 = 0 ;
    7773           2 :   PyObject * obj1 = 0 ;
    7774           4 :   lldb::SBBreakpointLocation result;
    7775             :   
    7776           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_FindLocationByAddress",&obj0,&obj1)) SWIG_fail;
    7777           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7778           2 :   if (!SWIG_IsOK(res1)) {
    7779           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_FindLocationByAddress" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7780             :   }
    7781           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7782           2 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    7783           2 :   if (!SWIG_IsOK(ecode2)) {
    7784           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_FindLocationByAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
    7785             :   } 
    7786           2 :   arg2 = static_cast< lldb::addr_t >(val2);
    7787             :   {
    7788           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7789           2 :     result = (arg1)->FindLocationByAddress(arg2);
    7790           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7791             :   }
    7792           2 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(static_cast< const lldb::SBBreakpointLocation& >(result))), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
    7793           2 :   return resultobj;
    7794           0 : fail:
    7795             :   return NULL;
    7796             : }
    7797             : 
    7798             : 
    7799           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationIDByAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7800           2 :   PyObject *resultobj = 0;
    7801           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7802             :   lldb::addr_t arg2 ;
    7803           2 :   void *argp1 = 0 ;
    7804           2 :   int res1 = 0 ;
    7805             :   unsigned long long val2 ;
    7806           2 :   int ecode2 = 0 ;
    7807           2 :   PyObject * obj0 = 0 ;
    7808           2 :   PyObject * obj1 = 0 ;
    7809             :   lldb::break_id_t result;
    7810             :   
    7811           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_FindLocationIDByAddress",&obj0,&obj1)) SWIG_fail;
    7812           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7813           2 :   if (!SWIG_IsOK(res1)) {
    7814           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_FindLocationIDByAddress" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7815             :   }
    7816           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7817           2 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    7818           2 :   if (!SWIG_IsOK(ecode2)) {
    7819           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_FindLocationIDByAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
    7820             :   } 
    7821           2 :   arg2 = static_cast< lldb::addr_t >(val2);
    7822             :   {
    7823           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7824           2 :     result = (lldb::break_id_t)(arg1)->FindLocationIDByAddress(arg2);
    7825           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7826             :   }
    7827           2 :   resultobj = SWIG_From_int(static_cast< int >(result));
    7828           2 :   return resultobj;
    7829           0 : fail:
    7830             :   return NULL;
    7831             : }
    7832             : 
    7833             : 
    7834           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationByID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7835           2 :   PyObject *resultobj = 0;
    7836           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7837             :   lldb::break_id_t arg2 ;
    7838           2 :   void *argp1 = 0 ;
    7839           2 :   int res1 = 0 ;
    7840             :   int val2 ;
    7841           2 :   int ecode2 = 0 ;
    7842           2 :   PyObject * obj0 = 0 ;
    7843           2 :   PyObject * obj1 = 0 ;
    7844           4 :   lldb::SBBreakpointLocation result;
    7845             :   
    7846           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_FindLocationByID",&obj0,&obj1)) SWIG_fail;
    7847           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7848           2 :   if (!SWIG_IsOK(res1)) {
    7849           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_FindLocationByID" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7850             :   }
    7851           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7852           4 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    7853           2 :   if (!SWIG_IsOK(ecode2)) {
    7854           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_FindLocationByID" "', argument " "2"" of type '" "lldb::break_id_t""'");
    7855             :   } 
    7856           2 :   arg2 = static_cast< lldb::break_id_t >(val2);
    7857             :   {
    7858           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7859           2 :     result = (arg1)->FindLocationByID(arg2);
    7860           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7861             :   }
    7862           2 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(static_cast< const lldb::SBBreakpointLocation& >(result))), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
    7863           2 :   return resultobj;
    7864           0 : fail:
    7865             :   return NULL;
    7866             : }
    7867             : 
    7868             : 
    7869         122 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetLocationAtIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7870         122 :   PyObject *resultobj = 0;
    7871         122 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7872             :   uint32_t arg2 ;
    7873         122 :   void *argp1 = 0 ;
    7874         122 :   int res1 = 0 ;
    7875             :   unsigned int val2 ;
    7876         122 :   int ecode2 = 0 ;
    7877         122 :   PyObject * obj0 = 0 ;
    7878         122 :   PyObject * obj1 = 0 ;
    7879         244 :   lldb::SBBreakpointLocation result;
    7880             :   
    7881         122 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_GetLocationAtIndex",&obj0,&obj1)) SWIG_fail;
    7882         122 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7883         122 :   if (!SWIG_IsOK(res1)) {
    7884           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetLocationAtIndex" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7885             :   }
    7886         122 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7887         244 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    7888         122 :   if (!SWIG_IsOK(ecode2)) {
    7889           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_GetLocationAtIndex" "', argument " "2"" of type '" "uint32_t""'");
    7890             :   } 
    7891         122 :   arg2 = static_cast< uint32_t >(val2);
    7892             :   {
    7893         244 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7894         122 :     result = (arg1)->GetLocationAtIndex(arg2);
    7895         122 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7896             :   }
    7897         122 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(static_cast< const lldb::SBBreakpointLocation& >(result))), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
    7898         122 :   return resultobj;
    7899           0 : fail:
    7900             :   return NULL;
    7901             : }
    7902             : 
    7903             : 
    7904          10 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7905          10 :   PyObject *resultobj = 0;
    7906          10 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7907             :   bool arg2 ;
    7908          10 :   void *argp1 = 0 ;
    7909          10 :   int res1 = 0 ;
    7910             :   bool val2 ;
    7911          10 :   int ecode2 = 0 ;
    7912          10 :   PyObject * obj0 = 0 ;
    7913          10 :   PyObject * obj1 = 0 ;
    7914             :   
    7915          10 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetEnabled",&obj0,&obj1)) SWIG_fail;
    7916          10 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7917          10 :   if (!SWIG_IsOK(res1)) {
    7918           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetEnabled" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7919             :   }
    7920          10 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7921          20 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    7922             :   if (!SWIG_IsOK(ecode2)) {
    7923           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetEnabled" "', argument " "2"" of type '" "bool""'");
    7924             :   } 
    7925          10 :   arg2 = static_cast< bool >(val2);
    7926             :   {
    7927          20 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7928          10 :     (arg1)->SetEnabled(arg2);
    7929          10 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7930             :   }
    7931          10 :   resultobj = SWIG_Py_Void();
    7932          10 :   return resultobj;
    7933           0 : fail:
    7934             :   return NULL;
    7935             : }
    7936             : 
    7937             : 
    7938          10 : SWIGINTERN PyObject *_wrap_SBBreakpoint_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7939          10 :   PyObject *resultobj = 0;
    7940          10 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7941          10 :   void *argp1 = 0 ;
    7942          10 :   int res1 = 0 ;
    7943          10 :   PyObject * obj0 = 0 ;
    7944             :   bool result;
    7945             :   
    7946          10 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_IsEnabled",&obj0)) SWIG_fail;
    7947          10 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7948          10 :   if (!SWIG_IsOK(res1)) {
    7949           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsEnabled" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7950             :   }
    7951          10 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7952             :   {
    7953          20 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7954          10 :     result = (bool)(arg1)->IsEnabled();
    7955          10 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7956             :   }
    7957          10 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7958          10 :   return resultobj;
    7959           0 : fail:
    7960             :   return NULL;
    7961             : }
    7962             : 
    7963             : 
    7964           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7965           4 :   PyObject *resultobj = 0;
    7966           4 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7967             :   bool arg2 ;
    7968           4 :   void *argp1 = 0 ;
    7969           4 :   int res1 = 0 ;
    7970             :   bool val2 ;
    7971           4 :   int ecode2 = 0 ;
    7972           4 :   PyObject * obj0 = 0 ;
    7973           4 :   PyObject * obj1 = 0 ;
    7974             :   
    7975           4 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetOneShot",&obj0,&obj1)) SWIG_fail;
    7976           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7977           4 :   if (!SWIG_IsOK(res1)) {
    7978           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetOneShot" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7979             :   }
    7980           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7981           8 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    7982             :   if (!SWIG_IsOK(ecode2)) {
    7983           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetOneShot" "', argument " "2"" of type '" "bool""'");
    7984             :   } 
    7985           4 :   arg2 = static_cast< bool >(val2);
    7986             :   {
    7987           8 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7988           4 :     (arg1)->SetOneShot(arg2);
    7989           4 :     SWIG_PYTHON_THREAD_END_ALLOW;
    7990             :   }
    7991           4 :   resultobj = SWIG_Py_Void();
    7992           4 :   return resultobj;
    7993           0 : fail:
    7994             :   return NULL;
    7995             : }
    7996             : 
    7997             : 
    7998           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7999           2 :   PyObject *resultobj = 0;
    8000           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8001           2 :   void *argp1 = 0 ;
    8002           2 :   int res1 = 0 ;
    8003           2 :   PyObject * obj0 = 0 ;
    8004             :   bool result;
    8005             :   
    8006           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_IsOneShot",&obj0)) SWIG_fail;
    8007           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8008           2 :   if (!SWIG_IsOK(res1)) {
    8009           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsOneShot" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8010             :   }
    8011           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8012             :   {
    8013           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8014           2 :     result = (bool)(arg1)->IsOneShot();
    8015           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8016             :   }
    8017           2 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8018           2 :   return resultobj;
    8019           0 : fail:
    8020             :   return NULL;
    8021             : }
    8022             : 
    8023             : 
    8024           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint_IsInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8025           0 :   PyObject *resultobj = 0;
    8026           0 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8027           0 :   void *argp1 = 0 ;
    8028           0 :   int res1 = 0 ;
    8029           0 :   PyObject * obj0 = 0 ;
    8030             :   bool result;
    8031             :   
    8032           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_IsInternal",&obj0)) SWIG_fail;
    8033           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8034           0 :   if (!SWIG_IsOK(res1)) {
    8035           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsInternal" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8036             :   }
    8037           0 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8038             :   {
    8039           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8040           0 :     result = (bool)(arg1)->IsInternal();
    8041           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8042             :   }
    8043           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8044           0 :   return resultobj;
    8045           0 : fail:
    8046             :   return NULL;
    8047             : }
    8048             : 
    8049             : 
    8050           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetHitCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8051           2 :   PyObject *resultobj = 0;
    8052           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8053           2 :   void *argp1 = 0 ;
    8054           2 :   int res1 = 0 ;
    8055           2 :   PyObject * obj0 = 0 ;
    8056             :   uint32_t result;
    8057             :   
    8058           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetHitCount",&obj0)) SWIG_fail;
    8059           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8060           2 :   if (!SWIG_IsOK(res1)) {
    8061           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetHitCount" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8062             :   }
    8063           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8064             :   {
    8065           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8066           2 :     result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetHitCount();
    8067           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8068             :   }
    8069           2 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    8070           2 :   return resultobj;
    8071           0 : fail:
    8072             :   return NULL;
    8073             : }
    8074             : 
    8075             : 
    8076           8 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetIgnoreCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8077           8 :   PyObject *resultobj = 0;
    8078           8 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8079             :   uint32_t arg2 ;
    8080           8 :   void *argp1 = 0 ;
    8081           8 :   int res1 = 0 ;
    8082             :   unsigned int val2 ;
    8083           8 :   int ecode2 = 0 ;
    8084           8 :   PyObject * obj0 = 0 ;
    8085           8 :   PyObject * obj1 = 0 ;
    8086             :   
    8087           8 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetIgnoreCount",&obj0,&obj1)) SWIG_fail;
    8088           8 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8089           8 :   if (!SWIG_IsOK(res1)) {
    8090           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8091             :   }
    8092           8 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8093          16 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    8094           8 :   if (!SWIG_IsOK(ecode2)) {
    8095           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetIgnoreCount" "', argument " "2"" of type '" "uint32_t""'");
    8096             :   } 
    8097           8 :   arg2 = static_cast< uint32_t >(val2);
    8098             :   {
    8099          16 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8100           8 :     (arg1)->SetIgnoreCount(arg2);
    8101           8 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8102             :   }
    8103           8 :   resultobj = SWIG_Py_Void();
    8104           8 :   return resultobj;
    8105           0 : fail:
    8106             :   return NULL;
    8107             : }
    8108             : 
    8109             : 
    8110           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetIgnoreCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8111           4 :   PyObject *resultobj = 0;
    8112           4 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8113           4 :   void *argp1 = 0 ;
    8114           4 :   int res1 = 0 ;
    8115           4 :   PyObject * obj0 = 0 ;
    8116             :   uint32_t result;
    8117             :   
    8118           4 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetIgnoreCount",&obj0)) SWIG_fail;
    8119           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8120           4 :   if (!SWIG_IsOK(res1)) {
    8121           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8122             :   }
    8123           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8124             :   {
    8125           8 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8126           4 :     result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetIgnoreCount();
    8127           4 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8128             :   }
    8129           4 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    8130           4 :   return resultobj;
    8131           0 : fail:
    8132             :   return NULL;
    8133             : }
    8134             : 
    8135             : 
    8136          12 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8137          12 :   PyObject *resultobj = 0;
    8138          12 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8139          12 :   char *arg2 = (char *) 0 ;
    8140          12 :   void *argp1 = 0 ;
    8141          12 :   int res1 = 0 ;
    8142             :   int res2 ;
    8143          12 :   char *buf2 = 0 ;
    8144          12 :   int alloc2 = 0 ;
    8145          12 :   PyObject * obj0 = 0 ;
    8146          12 :   PyObject * obj1 = 0 ;
    8147             :   
    8148          12 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetCondition",&obj0,&obj1)) SWIG_fail;
    8149          12 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8150          12 :   if (!SWIG_IsOK(res1)) {
    8151           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetCondition" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8152             :   }
    8153          12 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8154          12 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8155          12 :   if (!SWIG_IsOK(res2)) {
    8156           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetCondition" "', argument " "2"" of type '" "char const *""'");
    8157             :   }
    8158          12 :   arg2 = reinterpret_cast< char * >(buf2);
    8159             :   {
    8160          24 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8161          12 :     (arg1)->SetCondition((char const *)arg2);
    8162          12 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8163             :   }
    8164          12 :   resultobj = SWIG_Py_Void();
    8165          12 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8166             :   return resultobj;
    8167           0 : fail:
    8168           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8169             :   return NULL;
    8170             : }
    8171             : 
    8172             : 
    8173          10 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8174          10 :   PyObject *resultobj = 0;
    8175          10 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8176          10 :   void *argp1 = 0 ;
    8177          10 :   int res1 = 0 ;
    8178          10 :   PyObject * obj0 = 0 ;
    8179          10 :   char *result = 0 ;
    8180             :   
    8181          10 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetCondition",&obj0)) SWIG_fail;
    8182          10 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8183          10 :   if (!SWIG_IsOK(res1)) {
    8184           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetCondition" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8185             :   }
    8186          10 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8187             :   {
    8188          20 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8189          10 :     result = (char *)(arg1)->GetCondition();
    8190          10 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8191             :   }
    8192          10 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8193          10 :   return resultobj;
    8194           0 : fail:
    8195             :   return NULL;
    8196             : }
    8197             : 
    8198             : 
    8199           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetAutoContinue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8200           0 :   PyObject *resultobj = 0;
    8201           0 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8202             :   bool arg2 ;
    8203           0 :   void *argp1 = 0 ;
    8204           0 :   int res1 = 0 ;
    8205             :   bool val2 ;
    8206           0 :   int ecode2 = 0 ;
    8207           0 :   PyObject * obj0 = 0 ;
    8208           0 :   PyObject * obj1 = 0 ;
    8209             :   
    8210           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetAutoContinue",&obj0,&obj1)) SWIG_fail;
    8211           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8212           0 :   if (!SWIG_IsOK(res1)) {
    8213           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8214             :   }
    8215           0 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8216           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    8217             :   if (!SWIG_IsOK(ecode2)) {
    8218           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetAutoContinue" "', argument " "2"" of type '" "bool""'");
    8219             :   } 
    8220           0 :   arg2 = static_cast< bool >(val2);
    8221             :   {
    8222           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8223           0 :     (arg1)->SetAutoContinue(arg2);
    8224           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8225             :   }
    8226           0 :   resultobj = SWIG_Py_Void();
    8227           0 :   return resultobj;
    8228           0 : fail:
    8229             :   return NULL;
    8230             : }
    8231             : 
    8232             : 
    8233           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetAutoContinue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8234           0 :   PyObject *resultobj = 0;
    8235           0 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8236           0 :   void *argp1 = 0 ;
    8237           0 :   int res1 = 0 ;
    8238           0 :   PyObject * obj0 = 0 ;
    8239             :   bool result;
    8240             :   
    8241           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetAutoContinue",&obj0)) SWIG_fail;
    8242           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8243           0 :   if (!SWIG_IsOK(res1)) {
    8244           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8245             :   }
    8246           0 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8247             :   {
    8248           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8249           0 :     result = (bool)(arg1)->GetAutoContinue();
    8250           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8251             :   }
    8252           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8253           0 :   return resultobj;
    8254           0 : fail:
    8255             :   return NULL;
    8256             : }
    8257             : 
    8258             : 
    8259           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8260           6 :   PyObject *resultobj = 0;
    8261           6 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8262             :   lldb::tid_t arg2 ;
    8263           6 :   void *argp1 = 0 ;
    8264           6 :   int res1 = 0 ;
    8265           6 :   PyObject * obj0 = 0 ;
    8266           6 :   PyObject * obj1 = 0 ;
    8267             :   
    8268           6 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetThreadID",&obj0,&obj1)) SWIG_fail;
    8269           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8270           6 :   if (!SWIG_IsOK(res1)) {
    8271           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8272             :   }
    8273           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8274             :   {
    8275             :     using namespace lldb_private;
    8276           6 :     if (PythonInteger::Check(obj1))
    8277             :     {
    8278          12 :       PythonInteger py_int(PyRefType::Borrowed, obj1);
    8279           6 :       arg2 = static_cast<lldb::tid_t>(py_int.GetInteger());
    8280             :     }
    8281             :     else
    8282             :     {
    8283           0 :       PyErr_SetString(PyExc_ValueError, "Expecting an integer");
    8284           0 :       return nullptr;
    8285             :     }
    8286             :   }
    8287             :   {
    8288          12 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8289           6 :     (arg1)->SetThreadID(arg2);
    8290           6 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8291             :   }
    8292           6 :   resultobj = SWIG_Py_Void();
    8293           6 :   return resultobj;
    8294           0 : fail:
    8295             :   return NULL;
    8296             : }
    8297             : 
    8298             : 
    8299           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8300           2 :   PyObject *resultobj = 0;
    8301           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8302           2 :   void *argp1 = 0 ;
    8303           2 :   int res1 = 0 ;
    8304           2 :   PyObject * obj0 = 0 ;
    8305             :   lldb::tid_t result;
    8306             :   
    8307           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetThreadID",&obj0)) SWIG_fail;
    8308           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8309           2 :   if (!SWIG_IsOK(res1)) {
    8310           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8311             :   }
    8312           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8313             :   {
    8314           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8315           2 :     result = (lldb::tid_t)(arg1)->GetThreadID();
    8316           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8317             :   }
    8318           2 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    8319           2 :   return resultobj;
    8320           0 : fail:
    8321             :   return NULL;
    8322             : }
    8323             : 
    8324             : 
    8325           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8326           4 :   PyObject *resultobj = 0;
    8327           4 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8328             :   uint32_t arg2 ;
    8329           4 :   void *argp1 = 0 ;
    8330           4 :   int res1 = 0 ;
    8331             :   unsigned int val2 ;
    8332           4 :   int ecode2 = 0 ;
    8333           4 :   PyObject * obj0 = 0 ;
    8334           4 :   PyObject * obj1 = 0 ;
    8335             :   
    8336           4 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetThreadIndex",&obj0,&obj1)) SWIG_fail;
    8337           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8338           4 :   if (!SWIG_IsOK(res1)) {
    8339           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8340             :   }
    8341           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8342           8 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    8343           4 :   if (!SWIG_IsOK(ecode2)) {
    8344           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetThreadIndex" "', argument " "2"" of type '" "uint32_t""'");
    8345             :   } 
    8346           4 :   arg2 = static_cast< uint32_t >(val2);
    8347             :   {
    8348           8 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8349           4 :     (arg1)->SetThreadIndex(arg2);
    8350           4 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8351             :   }
    8352           4 :   resultobj = SWIG_Py_Void();
    8353           4 :   return resultobj;
    8354           0 : fail:
    8355             :   return NULL;
    8356             : }
    8357             : 
    8358             : 
    8359           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8360           6 :   PyObject *resultobj = 0;
    8361           6 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8362           6 :   void *argp1 = 0 ;
    8363           6 :   int res1 = 0 ;
    8364           6 :   PyObject * obj0 = 0 ;
    8365             :   uint32_t result;
    8366             :   
    8367           6 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetThreadIndex",&obj0)) SWIG_fail;
    8368           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8369           6 :   if (!SWIG_IsOK(res1)) {
    8370           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8371             :   }
    8372           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8373             :   {
    8374          12 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8375           6 :     result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetThreadIndex();
    8376           6 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8377             :   }
    8378           6 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    8379           6 :   return resultobj;
    8380           0 : fail:
    8381             :   return NULL;
    8382             : }
    8383             : 
    8384             : 
    8385           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8386           6 :   PyObject *resultobj = 0;
    8387           6 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8388           6 :   char *arg2 = (char *) 0 ;
    8389           6 :   void *argp1 = 0 ;
    8390           6 :   int res1 = 0 ;
    8391             :   int res2 ;
    8392           6 :   char *buf2 = 0 ;
    8393           6 :   int alloc2 = 0 ;
    8394           6 :   PyObject * obj0 = 0 ;
    8395           6 :   PyObject * obj1 = 0 ;
    8396             :   
    8397           6 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetThreadName",&obj0,&obj1)) SWIG_fail;
    8398           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8399           6 :   if (!SWIG_IsOK(res1)) {
    8400           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetThreadName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8401             :   }
    8402           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8403           6 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8404           6 :   if (!SWIG_IsOK(res2)) {
    8405           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetThreadName" "', argument " "2"" of type '" "char const *""'");
    8406             :   }
    8407           6 :   arg2 = reinterpret_cast< char * >(buf2);
    8408             :   {
    8409          12 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8410           6 :     (arg1)->SetThreadName((char const *)arg2);
    8411           6 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8412             :   }
    8413           6 :   resultobj = SWIG_Py_Void();
    8414           6 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8415             :   return resultobj;
    8416           0 : fail:
    8417           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8418             :   return NULL;
    8419             : }
    8420             : 
    8421             : 
    8422           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8423           4 :   PyObject *resultobj = 0;
    8424           4 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8425           4 :   void *argp1 = 0 ;
    8426           4 :   int res1 = 0 ;
    8427           4 :   PyObject * obj0 = 0 ;
    8428           4 :   char *result = 0 ;
    8429             :   
    8430           4 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetThreadName",&obj0)) SWIG_fail;
    8431           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8432           4 :   if (!SWIG_IsOK(res1)) {
    8433           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetThreadName" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8434             :   }
    8435           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8436             :   {
    8437           8 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8438           4 :     result = (char *)((lldb::SBBreakpoint const *)arg1)->GetThreadName();
    8439           4 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8440             :   }
    8441           4 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8442           4 :   return resultobj;
    8443           0 : fail:
    8444             :   return NULL;
    8445             : }
    8446             : 
    8447             : 
    8448           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetQueueName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8449           6 :   PyObject *resultobj = 0;
    8450           6 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8451           6 :   char *arg2 = (char *) 0 ;
    8452           6 :   void *argp1 = 0 ;
    8453           6 :   int res1 = 0 ;
    8454             :   int res2 ;
    8455           6 :   char *buf2 = 0 ;
    8456           6 :   int alloc2 = 0 ;
    8457           6 :   PyObject * obj0 = 0 ;
    8458           6 :   PyObject * obj1 = 0 ;
    8459             :   
    8460           6 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetQueueName",&obj0,&obj1)) SWIG_fail;
    8461           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8462           6 :   if (!SWIG_IsOK(res1)) {
    8463           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetQueueName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8464             :   }
    8465           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8466           6 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8467           6 :   if (!SWIG_IsOK(res2)) {
    8468           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetQueueName" "', argument " "2"" of type '" "char const *""'");
    8469             :   }
    8470           6 :   arg2 = reinterpret_cast< char * >(buf2);
    8471             :   {
    8472          12 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8473           6 :     (arg1)->SetQueueName((char const *)arg2);
    8474           6 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8475             :   }
    8476           6 :   resultobj = SWIG_Py_Void();
    8477           6 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8478             :   return resultobj;
    8479           0 : fail:
    8480           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8481             :   return NULL;
    8482             : }
    8483             : 
    8484             : 
    8485           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetQueueName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8486           2 :   PyObject *resultobj = 0;
    8487           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8488           2 :   void *argp1 = 0 ;
    8489           2 :   int res1 = 0 ;
    8490           2 :   PyObject * obj0 = 0 ;
    8491           2 :   char *result = 0 ;
    8492             :   
    8493           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetQueueName",&obj0)) SWIG_fail;
    8494           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8495           2 :   if (!SWIG_IsOK(res1)) {
    8496           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetQueueName" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8497             :   }
    8498           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8499             :   {
    8500           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8501           2 :     result = (char *)((lldb::SBBreakpoint const *)arg1)->GetQueueName();
    8502           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8503             :   }
    8504           2 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8505           2 :   return resultobj;
    8506           0 : fail:
    8507             :   return NULL;
    8508             : }
    8509             : 
    8510             : 
    8511           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8512           4 :   PyObject *resultobj = 0;
    8513           4 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8514           4 :   char *arg2 = (char *) 0 ;
    8515           4 :   void *argp1 = 0 ;
    8516           4 :   int res1 = 0 ;
    8517             :   int res2 ;
    8518           4 :   char *buf2 = 0 ;
    8519           4 :   int alloc2 = 0 ;
    8520           4 :   PyObject * obj0 = 0 ;
    8521           4 :   PyObject * obj1 = 0 ;
    8522             :   
    8523           4 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetScriptCallbackFunction",&obj0,&obj1)) SWIG_fail;
    8524           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8525           4 :   if (!SWIG_IsOK(res1)) {
    8526           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetScriptCallbackFunction" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8527             :   }
    8528           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8529           4 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8530           4 :   if (!SWIG_IsOK(res2)) {
    8531           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetScriptCallbackFunction" "', argument " "2"" of type '" "char const *""'");
    8532             :   }
    8533           4 :   arg2 = reinterpret_cast< char * >(buf2);
    8534             :   {
    8535           8 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8536           4 :     (arg1)->SetScriptCallbackFunction((char const *)arg2);
    8537           4 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8538             :   }
    8539           4 :   resultobj = SWIG_Py_Void();
    8540           4 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8541             :   return resultobj;
    8542           0 : fail:
    8543           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8544             :   return NULL;
    8545             : }
    8546             : 
    8547             : 
    8548           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8549           6 :   PyObject *resultobj = 0;
    8550           6 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8551           6 :   char *arg2 = (char *) 0 ;
    8552           6 :   void *argp1 = 0 ;
    8553           6 :   int res1 = 0 ;
    8554             :   int res2 ;
    8555           6 :   char *buf2 = 0 ;
    8556           6 :   int alloc2 = 0 ;
    8557           6 :   PyObject * obj0 = 0 ;
    8558           6 :   PyObject * obj1 = 0 ;
    8559          12 :   lldb::SBError result;
    8560             :   
    8561           6 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetScriptCallbackBody",&obj0,&obj1)) SWIG_fail;
    8562           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8563           6 :   if (!SWIG_IsOK(res1)) {
    8564           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetScriptCallbackBody" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8565             :   }
    8566           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8567           6 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8568           6 :   if (!SWIG_IsOK(res2)) {
    8569           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetScriptCallbackBody" "', argument " "2"" of type '" "char const *""'");
    8570             :   }
    8571           6 :   arg2 = reinterpret_cast< char * >(buf2);
    8572             :   {
    8573          12 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8574           6 :     result = (arg1)->SetScriptCallbackBody((char const *)arg2);
    8575           6 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8576             :   }
    8577           6 :   resultobj = SWIG_NewPointerObj((new lldb::SBError(static_cast< const lldb::SBError& >(result))), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
    8578           6 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8579             :   return resultobj;
    8580           0 : fail:
    8581           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8582             :   return NULL;
    8583             : }
    8584             : 
    8585             : 
    8586           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetCommandLineCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8587           4 :   PyObject *resultobj = 0;
    8588           4 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8589           4 :   lldb::SBStringList *arg2 = 0 ;
    8590           4 :   void *argp1 = 0 ;
    8591           4 :   int res1 = 0 ;
    8592           4 :   void *argp2 = 0 ;
    8593           4 :   int res2 = 0 ;
    8594           4 :   PyObject * obj0 = 0 ;
    8595           4 :   PyObject * obj1 = 0 ;
    8596             :   
    8597           4 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetCommandLineCommands",&obj0,&obj1)) SWIG_fail;
    8598           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8599           4 :   if (!SWIG_IsOK(res1)) {
    8600           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8601             :   }
    8602           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8603           4 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
    8604           4 :   if (!SWIG_IsOK(res2)) {
    8605           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8606             :   }
    8607           4 :   if (!argp2) {
    8608           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8609             :   }
    8610           4 :   arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
    8611             :   {
    8612           8 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8613           4 :     (arg1)->SetCommandLineCommands(*arg2);
    8614           4 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8615             :   }
    8616           4 :   resultobj = SWIG_Py_Void();
    8617           4 :   return resultobj;
    8618           0 : fail:
    8619             :   return NULL;
    8620             : }
    8621             : 
    8622             : 
    8623           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetCommandLineCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8624           4 :   PyObject *resultobj = 0;
    8625           4 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8626           4 :   lldb::SBStringList *arg2 = 0 ;
    8627           4 :   void *argp1 = 0 ;
    8628           4 :   int res1 = 0 ;
    8629           4 :   void *argp2 = 0 ;
    8630           4 :   int res2 = 0 ;
    8631           4 :   PyObject * obj0 = 0 ;
    8632           4 :   PyObject * obj1 = 0 ;
    8633             :   bool result;
    8634             :   
    8635           4 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_GetCommandLineCommands",&obj0,&obj1)) SWIG_fail;
    8636           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8637           4 :   if (!SWIG_IsOK(res1)) {
    8638           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8639             :   }
    8640           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8641           4 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
    8642           4 :   if (!SWIG_IsOK(res2)) {
    8643           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8644             :   }
    8645           4 :   if (!argp2) {
    8646           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8647             :   }
    8648           4 :   arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
    8649             :   {
    8650           8 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8651           4 :     result = (bool)(arg1)->GetCommandLineCommands(*arg2);
    8652           4 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8653             :   }
    8654           4 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8655           4 :   return resultobj;
    8656           0 : fail:
    8657             :   return NULL;
    8658             : }
    8659             : 
    8660             : 
    8661          26 : SWIGINTERN PyObject *_wrap_SBBreakpoint_AddName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8662          26 :   PyObject *resultobj = 0;
    8663          26 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8664          26 :   char *arg2 = (char *) 0 ;
    8665          26 :   void *argp1 = 0 ;
    8666          26 :   int res1 = 0 ;
    8667             :   int res2 ;
    8668          26 :   char *buf2 = 0 ;
    8669          26 :   int alloc2 = 0 ;
    8670          26 :   PyObject * obj0 = 0 ;
    8671          26 :   PyObject * obj1 = 0 ;
    8672             :   bool result;
    8673             :   
    8674          26 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_AddName",&obj0,&obj1)) SWIG_fail;
    8675          26 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8676          26 :   if (!SWIG_IsOK(res1)) {
    8677           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_AddName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8678             :   }
    8679          26 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8680          26 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8681          26 :   if (!SWIG_IsOK(res2)) {
    8682           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_AddName" "', argument " "2"" of type '" "char const *""'");
    8683             :   }
    8684          26 :   arg2 = reinterpret_cast< char * >(buf2);
    8685             :   {
    8686          52 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8687          26 :     result = (bool)(arg1)->AddName((char const *)arg2);
    8688          26 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8689             :   }
    8690          26 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8691          26 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8692             :   return resultobj;
    8693           0 : fail:
    8694           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8695             :   return NULL;
    8696             : }
    8697             : 
    8698             : 
    8699           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_RemoveName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8700           2 :   PyObject *resultobj = 0;
    8701           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8702           2 :   char *arg2 = (char *) 0 ;
    8703           2 :   void *argp1 = 0 ;
    8704           2 :   int res1 = 0 ;
    8705             :   int res2 ;
    8706           2 :   char *buf2 = 0 ;
    8707           2 :   int alloc2 = 0 ;
    8708           2 :   PyObject * obj0 = 0 ;
    8709           2 :   PyObject * obj1 = 0 ;
    8710             :   
    8711           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_RemoveName",&obj0,&obj1)) SWIG_fail;
    8712           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8713           2 :   if (!SWIG_IsOK(res1)) {
    8714           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_RemoveName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8715             :   }
    8716           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8717           2 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8718           2 :   if (!SWIG_IsOK(res2)) {
    8719           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_RemoveName" "', argument " "2"" of type '" "char const *""'");
    8720             :   }
    8721           2 :   arg2 = reinterpret_cast< char * >(buf2);
    8722             :   {
    8723           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8724           2 :     (arg1)->RemoveName((char const *)arg2);
    8725           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8726             :   }
    8727           2 :   resultobj = SWIG_Py_Void();
    8728           2 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8729             :   return resultobj;
    8730           0 : fail:
    8731           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8732             :   return NULL;
    8733             : }
    8734             : 
    8735             : 
    8736           8 : SWIGINTERN PyObject *_wrap_SBBreakpoint_MatchesName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8737           8 :   PyObject *resultobj = 0;
    8738           8 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8739           8 :   char *arg2 = (char *) 0 ;
    8740           8 :   void *argp1 = 0 ;
    8741           8 :   int res1 = 0 ;
    8742             :   int res2 ;
    8743           8 :   char *buf2 = 0 ;
    8744           8 :   int alloc2 = 0 ;
    8745           8 :   PyObject * obj0 = 0 ;
    8746           8 :   PyObject * obj1 = 0 ;
    8747             :   bool result;
    8748             :   
    8749           8 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_MatchesName",&obj0,&obj1)) SWIG_fail;
    8750           8 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8751           8 :   if (!SWIG_IsOK(res1)) {
    8752           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_MatchesName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8753             :   }
    8754           8 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8755           8 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8756           8 :   if (!SWIG_IsOK(res2)) {
    8757           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_MatchesName" "', argument " "2"" of type '" "char const *""'");
    8758             :   }
    8759           8 :   arg2 = reinterpret_cast< char * >(buf2);
    8760             :   {
    8761          16 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8762           8 :     result = (bool)(arg1)->MatchesName((char const *)arg2);
    8763           8 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8764             :   }
    8765           8 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8766           8 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8767             :   return resultobj;
    8768           0 : fail:
    8769           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8770             :   return NULL;
    8771             : }
    8772             : 
    8773             : 
    8774           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8775           2 :   PyObject *resultobj = 0;
    8776           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8777           2 :   lldb::SBStringList *arg2 = 0 ;
    8778           2 :   void *argp1 = 0 ;
    8779           2 :   int res1 = 0 ;
    8780           2 :   void *argp2 = 0 ;
    8781           2 :   int res2 = 0 ;
    8782           2 :   PyObject * obj0 = 0 ;
    8783           2 :   PyObject * obj1 = 0 ;
    8784             :   
    8785           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_GetNames",&obj0,&obj1)) SWIG_fail;
    8786           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8787           2 :   if (!SWIG_IsOK(res1)) {
    8788           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNames" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8789             :   }
    8790           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8791           2 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
    8792           2 :   if (!SWIG_IsOK(res2)) {
    8793           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetNames" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8794             :   }
    8795           2 :   if (!argp2) {
    8796           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetNames" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8797             :   }
    8798           2 :   arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
    8799             :   {
    8800           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8801           2 :     (arg1)->GetNames(*arg2);
    8802           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8803             :   }
    8804           2 :   resultobj = SWIG_Py_Void();
    8805           2 :   return resultobj;
    8806           0 : fail:
    8807             :   return NULL;
    8808             : }
    8809             : 
    8810             : 
    8811           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumResolvedLocations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8812           2 :   PyObject *resultobj = 0;
    8813           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8814           2 :   void *argp1 = 0 ;
    8815           2 :   int res1 = 0 ;
    8816           2 :   PyObject * obj0 = 0 ;
    8817             :   size_t result;
    8818             :   
    8819           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetNumResolvedLocations",&obj0)) SWIG_fail;
    8820           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8821           2 :   if (!SWIG_IsOK(res1)) {
    8822           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNumResolvedLocations" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8823             :   }
    8824           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8825             :   {
    8826           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8827           2 :     result = ((lldb::SBBreakpoint const *)arg1)->GetNumResolvedLocations();
    8828           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8829             :   }
    8830           2 :   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
    8831           2 :   return resultobj;
    8832           0 : fail:
    8833             :   return NULL;
    8834             : }
    8835             : 
    8836             : 
    8837         309 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumLocations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8838         309 :   PyObject *resultobj = 0;
    8839         309 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8840         309 :   void *argp1 = 0 ;
    8841         309 :   int res1 = 0 ;
    8842         309 :   PyObject * obj0 = 0 ;
    8843             :   size_t result;
    8844             :   
    8845         309 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetNumLocations",&obj0)) SWIG_fail;
    8846         309 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8847         309 :   if (!SWIG_IsOK(res1)) {
    8848           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNumLocations" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8849             :   }
    8850         309 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8851             :   {
    8852         618 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8853         309 :     result = ((lldb::SBBreakpoint const *)arg1)->GetNumLocations();
    8854         309 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8855             :   }
    8856         309 :   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
    8857         309 :   return resultobj;
    8858           0 : fail:
    8859             :   return NULL;
    8860             : }
    8861             : 
    8862             : 
    8863           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8864           2 :   PyObject *resultobj = 0;
    8865           2 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8866           2 :   lldb::SBStream *arg2 = 0 ;
    8867           2 :   void *argp1 = 0 ;
    8868           2 :   int res1 = 0 ;
    8869           2 :   void *argp2 = 0 ;
    8870           2 :   int res2 = 0 ;
    8871           2 :   PyObject * obj0 = 0 ;
    8872           2 :   PyObject * obj1 = 0 ;
    8873             :   bool result;
    8874             :   
    8875           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_GetDescription",&obj0,&obj1)) SWIG_fail;
    8876           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8877           2 :   if (!SWIG_IsOK(res1)) {
    8878           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetDescription" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8879             :   }
    8880           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8881           2 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
    8882           2 :   if (!SWIG_IsOK(res2)) {
    8883           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    8884             :   }
    8885           2 :   if (!argp2) {
    8886           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    8887             :   }
    8888           2 :   arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
    8889             :   {
    8890           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8891           2 :     result = (bool)(arg1)->GetDescription(*arg2);
    8892           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8893             :   }
    8894           2 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8895             :   return resultobj;
    8896             : fail:
    8897             :   return NULL;
    8898             : }
    8899             : 
    8900             : 
    8901          60 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8902          60 :   PyObject *resultobj = 0;
    8903          60 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8904          60 :   lldb::SBStream *arg2 = 0 ;
    8905             :   bool arg3 ;
    8906          60 :   void *argp1 = 0 ;
    8907          60 :   int res1 = 0 ;
    8908          60 :   void *argp2 = 0 ;
    8909          60 :   int res2 = 0 ;
    8910             :   bool val3 ;
    8911          60 :   int ecode3 = 0 ;
    8912          60 :   PyObject * obj0 = 0 ;
    8913          60 :   PyObject * obj1 = 0 ;
    8914          60 :   PyObject * obj2 = 0 ;
    8915             :   bool result;
    8916             :   
    8917          60 :   if (!PyArg_ParseTuple(args,(char *)"OOO:SBBreakpoint_GetDescription",&obj0,&obj1,&obj2)) SWIG_fail;
    8918          60 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8919          60 :   if (!SWIG_IsOK(res1)) {
    8920           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetDescription" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8921             :   }
    8922          60 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8923          60 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
    8924          60 :   if (!SWIG_IsOK(res2)) {
    8925           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    8926             :   }
    8927          60 :   if (!argp2) {
    8928           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    8929             :   }
    8930          60 :   arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
    8931         120 :   ecode3 = SWIG_AsVal_bool(obj2, &val3);
    8932             :   if (!SWIG_IsOK(ecode3)) {
    8933           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBreakpoint_GetDescription" "', argument " "3"" of type '" "bool""'");
    8934             :   } 
    8935          60 :   arg3 = static_cast< bool >(val3);
    8936             :   {
    8937         120 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8938          60 :     result = (bool)(arg1)->GetDescription(*arg2,arg3);
    8939          60 :     SWIG_PYTHON_THREAD_END_ALLOW;
    8940             :   }
    8941          60 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8942             :   return resultobj;
    8943             : fail:
    8944             :   return NULL;
    8945             : }
    8946             : 
    8947             : 
    8948          62 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription(PyObject *self, PyObject *args) {
    8949             :   Py_ssize_t argc;
    8950          62 :   PyObject *argv[4] = {
    8951             :     0
    8952             :   };
    8953             :   Py_ssize_t ii;
    8954             :   
    8955          62 :   if (!PyTuple_Check(args)) SWIG_fail;
    8956          62 :   argc = args ? PyObject_Length(args) : 0;
    8957         246 :   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    8958         184 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    8959             :   }
    8960          62 :   if (argc == 2) {
    8961             :     int _v;
    8962           2 :     void *vptr = 0;
    8963           2 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpoint, 0);
    8964           2 :     _v = SWIG_CheckState(res);
    8965             :     if (_v) {
    8966           2 :       void *vptr = 0;
    8967           2 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, 0);
    8968           2 :       _v = SWIG_CheckState(res);
    8969             :       if (_v) {
    8970           2 :         return _wrap_SBBreakpoint_GetDescription__SWIG_0(self, args);
    8971             :       }
    8972             :     }
    8973             :   }
    8974          60 :   if (argc == 3) {
    8975             :     int _v;
    8976          60 :     void *vptr = 0;
    8977          60 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpoint, 0);
    8978          60 :     _v = SWIG_CheckState(res);
    8979             :     if (_v) {
    8980          60 :       void *vptr = 0;
    8981          60 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, 0);
    8982          60 :       _v = SWIG_CheckState(res);
    8983             :       if (_v) {
    8984             :         {
    8985         120 :           int res = SWIG_AsVal_bool(argv[2], NULL);
    8986          60 :           _v = SWIG_CheckState(res);
    8987             :         }
    8988             :         if (_v) {
    8989          60 :           return _wrap_SBBreakpoint_GetDescription__SWIG_1(self, args);
    8990             :         }
    8991             :       }
    8992             :     }
    8993             :   }
    8994             :   
    8995           0 : fail:
    8996           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SBBreakpoint_GetDescription'.\n"
    8997             :     "  Possible C/C++ prototypes are:\n"
    8998             :     "    lldb::SBBreakpoint::GetDescription(lldb::SBStream &)\n"
    8999             :     "    lldb::SBBreakpoint::GetDescription(lldb::SBStream &,bool)\n");
    9000           0 :   return 0;
    9001             : }
    9002             : 
    9003             : 
    9004           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9005           6 :   PyObject *resultobj = 0;
    9006           6 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    9007           6 :   lldb::SBBreakpoint *arg2 = 0 ;
    9008           6 :   void *argp1 = 0 ;
    9009           6 :   int res1 = 0 ;
    9010           6 :   void *argp2 = 0 ;
    9011           6 :   int res2 = 0 ;
    9012           6 :   PyObject * obj0 = 0 ;
    9013           6 :   PyObject * obj1 = 0 ;
    9014             :   bool result;
    9015             :   
    9016           6 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint___eq__",&obj0,&obj1)) SWIG_fail;
    9017           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    9018           6 :   if (!SWIG_IsOK(res1)) {
    9019           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint___eq__" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    9020             :   }
    9021           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    9022           6 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
    9023           6 :   if (!SWIG_IsOK(res2)) {
    9024           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint___eq__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9025             :   }
    9026           6 :   if (!argp2) {
    9027           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint___eq__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9028             :   }
    9029           6 :   arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
    9030             :   {
    9031          12 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9032           6 :     result = (bool)(arg1)->operator ==((lldb::SBBreakpoint const &)*arg2);
    9033           6 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9034             :   }
    9035           6 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9036           6 :   return resultobj;
    9037           0 : fail:
    9038             :   return NULL;
    9039             : }
    9040             : 
    9041             : 
    9042           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9043           0 :   PyObject *resultobj = 0;
    9044           0 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    9045           0 :   lldb::SBBreakpoint *arg2 = 0 ;
    9046           0 :   void *argp1 = 0 ;
    9047           0 :   int res1 = 0 ;
    9048           0 :   void *argp2 = 0 ;
    9049           0 :   int res2 = 0 ;
    9050           0 :   PyObject * obj0 = 0 ;
    9051           0 :   PyObject * obj1 = 0 ;
    9052             :   bool result;
    9053             :   
    9054           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint___ne__",&obj0,&obj1)) SWIG_fail;
    9055           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    9056           0 :   if (!SWIG_IsOK(res1)) {
    9057           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint___ne__" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    9058             :   }
    9059           0 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    9060           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
    9061           0 :   if (!SWIG_IsOK(res2)) {
    9062           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint___ne__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9063             :   }
    9064           0 :   if (!argp2) {
    9065           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint___ne__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9066             :   }
    9067           0 :   arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
    9068             :   {
    9069           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9070           0 :     result = (bool)(arg1)->operator !=((lldb::SBBreakpoint const &)*arg2);
    9071           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9072             :   }
    9073           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9074           0 :   return resultobj;
    9075           0 : fail:
    9076             :   return NULL;
    9077             : }
    9078             : 
    9079             : 
    9080           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_EventIsBreakpointEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9081           2 :   PyObject *resultobj = 0;
    9082           2 :   lldb::SBEvent *arg1 = 0 ;
    9083           2 :   void *argp1 = 0 ;
    9084           2 :   int res1 = 0 ;
    9085           2 :   PyObject * obj0 = 0 ;
    9086             :   bool result;
    9087             :   
    9088           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_EventIsBreakpointEvent",&obj0)) SWIG_fail;
    9089           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
    9090           2 :   if (!SWIG_IsOK(res1)) {
    9091           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_EventIsBreakpointEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9092             :   }
    9093           2 :   if (!argp1) {
    9094           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_EventIsBreakpointEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9095             :   }
    9096           2 :   arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
    9097             :   {
    9098           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9099           2 :     result = (bool)lldb::SBBreakpoint::EventIsBreakpointEvent((lldb::SBEvent const &)*arg1);
    9100           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9101             :   }
    9102           2 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9103           2 :   return resultobj;
    9104           0 : fail:
    9105             :   return NULL;
    9106             : }
    9107             : 
    9108             : 
    9109           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetBreakpointEventTypeFromEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9110           2 :   PyObject *resultobj = 0;
    9111           2 :   lldb::SBEvent *arg1 = 0 ;
    9112           2 :   void *argp1 = 0 ;
    9113           2 :   int res1 = 0 ;
    9114           2 :   PyObject * obj0 = 0 ;
    9115             :   lldb::BreakpointEventType result;
    9116             :   
    9117           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetBreakpointEventTypeFromEvent",&obj0)) SWIG_fail;
    9118           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
    9119           2 :   if (!SWIG_IsOK(res1)) {
    9120           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetBreakpointEventTypeFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9121             :   }
    9122           2 :   if (!argp1) {
    9123           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetBreakpointEventTypeFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9124             :   }
    9125           2 :   arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
    9126             :   {
    9127           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9128           2 :     result = (lldb::BreakpointEventType)lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent((lldb::SBEvent const &)*arg1);
    9129           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9130             :   }
    9131           4 :   resultobj = SWIG_From_int(static_cast< int >(result));
    9132           2 :   return resultobj;
    9133           0 : fail:
    9134             :   return NULL;
    9135             : }
    9136             : 
    9137             : 
    9138           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetBreakpointFromEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9139           2 :   PyObject *resultobj = 0;
    9140           2 :   lldb::SBEvent *arg1 = 0 ;
    9141           2 :   void *argp1 = 0 ;
    9142           2 :   int res1 = 0 ;
    9143           2 :   PyObject * obj0 = 0 ;
    9144           4 :   lldb::SBBreakpoint result;
    9145             :   
    9146           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetBreakpointFromEvent",&obj0)) SWIG_fail;
    9147           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
    9148           2 :   if (!SWIG_IsOK(res1)) {
    9149           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetBreakpointFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9150             :   }
    9151           2 :   if (!argp1) {
    9152           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetBreakpointFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9153             :   }
    9154           2 :   arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
    9155             :   {
    9156           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9157           2 :     result = lldb::SBBreakpoint::GetBreakpointFromEvent((lldb::SBEvent const &)*arg1);
    9158           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9159             :   }
    9160           2 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(static_cast< const lldb::SBBreakpoint& >(result))), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
    9161           2 :   return resultobj;
    9162           0 : fail:
    9163             :   return NULL;
    9164             : }
    9165             : 
    9166             : 
    9167           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetBreakpointLocationAtIndexFromEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9168           0 :   PyObject *resultobj = 0;
    9169           0 :   lldb::SBEvent *arg1 = 0 ;
    9170             :   uint32_t arg2 ;
    9171           0 :   void *argp1 = 0 ;
    9172           0 :   int res1 = 0 ;
    9173             :   unsigned int val2 ;
    9174           0 :   int ecode2 = 0 ;
    9175           0 :   PyObject * obj0 = 0 ;
    9176           0 :   PyObject * obj1 = 0 ;
    9177           0 :   lldb::SBBreakpointLocation result;
    9178             :   
    9179           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_GetBreakpointLocationAtIndexFromEvent",&obj0,&obj1)) SWIG_fail;
    9180           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
    9181           0 :   if (!SWIG_IsOK(res1)) {
    9182           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9183             :   }
    9184           0 :   if (!argp1) {
    9185           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9186             :   }
    9187           0 :   arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
    9188           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    9189           0 :   if (!SWIG_IsOK(ecode2)) {
    9190           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent" "', argument " "2"" of type '" "uint32_t""'");
    9191             :   } 
    9192           0 :   arg2 = static_cast< uint32_t >(val2);
    9193             :   {
    9194           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9195           0 :     result = lldb::SBBreakpoint::GetBreakpointLocationAtIndexFromEvent((lldb::SBEvent const &)*arg1,arg2);
    9196           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9197             :   }
    9198           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(static_cast< const lldb::SBBreakpointLocation& >(result))), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
    9199           0 :   return resultobj;
    9200           0 : fail:
    9201             :   return NULL;
    9202             : }
    9203             : 
    9204             : 
    9205           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumBreakpointLocationsFromEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9206           0 :   PyObject *resultobj = 0;
    9207           0 :   lldb::SBEvent *arg1 = 0 ;
    9208           0 :   void *argp1 = 0 ;
    9209           0 :   int res1 = 0 ;
    9210           0 :   PyObject * obj0 = 0 ;
    9211             :   uint32_t result;
    9212             :   
    9213           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetNumBreakpointLocationsFromEvent",&obj0)) SWIG_fail;
    9214           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
    9215           0 :   if (!SWIG_IsOK(res1)) {
    9216           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNumBreakpointLocationsFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9217             :   }
    9218           0 :   if (!argp1) {
    9219           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetNumBreakpointLocationsFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9220             :   }
    9221           0 :   arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
    9222             :   {
    9223           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9224           0 :     result = (uint32_t)lldb::SBBreakpoint::GetNumBreakpointLocationsFromEvent((lldb::SBEvent const &)*arg1);
    9225           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9226             :   }
    9227           0 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    9228           0 :   return resultobj;
    9229           0 : fail:
    9230             :   return NULL;
    9231             : }
    9232             : 
    9233             : 
    9234           8 : SWIGINTERN PyObject *_wrap_SBBreakpoint___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9235           8 :   PyObject *resultobj = 0;
    9236           8 :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    9237           8 :   void *argp1 = 0 ;
    9238           8 :   int res1 = 0 ;
    9239           8 :   PyObject * obj0 = 0 ;
    9240           8 :   PyObject *result = 0 ;
    9241             :   
    9242           8 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint___str__",&obj0)) SWIG_fail;
    9243           8 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    9244           8 :   if (!SWIG_IsOK(res1)) {
    9245           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint___str__" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    9246             :   }
    9247           8 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    9248             :   {
    9249          16 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9250           8 :     result = (PyObject *)lldb_SBBreakpoint___str__(arg1);
    9251           8 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9252             :   }
    9253           8 :   resultobj = result;
    9254           8 :   return resultobj;
    9255           0 : fail:
    9256             :   return NULL;
    9257             : }
    9258             : 
    9259             : 
    9260         605 : SWIGINTERN PyObject *SBBreakpoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9261             :   PyObject *obj;
    9262         605 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    9263        1210 :   SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBreakpoint, SWIG_NewClientData(obj));
    9264         605 :   return SWIG_Py_Void();
    9265             : }
    9266             : 
    9267          30 : SWIGINTERN PyObject *_wrap_new_SBBreakpointList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9268          30 :   PyObject *resultobj = 0;
    9269          30 :   lldb::SBTarget *arg1 = 0 ;
    9270          30 :   void *argp1 = 0 ;
    9271          30 :   int res1 = 0 ;
    9272          30 :   PyObject * obj0 = 0 ;
    9273          30 :   lldb::SBBreakpointList *result = 0 ;
    9274             :   
    9275          30 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBBreakpointList",&obj0)) SWIG_fail;
    9276          30 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBTarget,  0 );
    9277          30 :   if (!SWIG_IsOK(res1)) {
    9278           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpointList" "', argument " "1"" of type '" "lldb::SBTarget &""'"); 
    9279             :   }
    9280          30 :   if (!argp1) {
    9281           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBBreakpointList" "', argument " "1"" of type '" "lldb::SBTarget &""'"); 
    9282             :   }
    9283          30 :   arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
    9284             :   {
    9285          60 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9286          30 :     result = (lldb::SBBreakpointList *)new lldb::SBBreakpointList(*arg1);
    9287          30 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9288             :   }
    9289          30 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NEW |  0 );
    9290          30 :   return resultobj;
    9291           0 : fail:
    9292             :   return NULL;
    9293             : }
    9294             : 
    9295             : 
    9296          30 : SWIGINTERN PyObject *_wrap_delete_SBBreakpointList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9297          30 :   PyObject *resultobj = 0;
    9298          30 :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9299          30 :   void *argp1 = 0 ;
    9300          30 :   int res1 = 0 ;
    9301          30 :   PyObject * obj0 = 0 ;
    9302             :   
    9303          30 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBBreakpointList",&obj0)) SWIG_fail;
    9304          30 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_DISOWN |  0 );
    9305          30 :   if (!SWIG_IsOK(res1)) {
    9306           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBreakpointList" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9307             :   }
    9308          30 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9309             :   {
    9310          60 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9311          30 :     delete arg1;
    9312          30 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9313             :   }
    9314          30 :   resultobj = SWIG_Py_Void();
    9315          30 :   return resultobj;
    9316           0 : fail:
    9317             :   return NULL;
    9318             : }
    9319             : 
    9320             : 
    9321          34 : SWIGINTERN PyObject *_wrap_SBBreakpointList_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9322          34 :   PyObject *resultobj = 0;
    9323          34 :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9324          34 :   void *argp1 = 0 ;
    9325          34 :   int res1 = 0 ;
    9326          34 :   PyObject * obj0 = 0 ;
    9327             :   size_t result;
    9328             :   
    9329          34 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointList_GetSize",&obj0)) SWIG_fail;
    9330          34 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9331          34 :   if (!SWIG_IsOK(res1)) {
    9332           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_GetSize" "', argument " "1"" of type '" "lldb::SBBreakpointList const *""'"); 
    9333             :   }
    9334          34 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9335             :   {
    9336          68 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9337          34 :     result = ((lldb::SBBreakpointList const *)arg1)->GetSize();
    9338          34 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9339             :   }
    9340          34 :   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
    9341          34 :   return resultobj;
    9342           0 : fail:
    9343             :   return NULL;
    9344             : }
    9345             : 
    9346             : 
    9347          32 : SWIGINTERN PyObject *_wrap_SBBreakpointList_GetBreakpointAtIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9348          32 :   PyObject *resultobj = 0;
    9349          32 :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9350             :   size_t arg2 ;
    9351          32 :   void *argp1 = 0 ;
    9352          32 :   int res1 = 0 ;
    9353             :   size_t val2 ;
    9354          32 :   int ecode2 = 0 ;
    9355          32 :   PyObject * obj0 = 0 ;
    9356          32 :   PyObject * obj1 = 0 ;
    9357          64 :   lldb::SBBreakpoint result;
    9358             :   
    9359          32 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointList_GetBreakpointAtIndex",&obj0,&obj1)) SWIG_fail;
    9360          32 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9361          32 :   if (!SWIG_IsOK(res1)) {
    9362           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_GetBreakpointAtIndex" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9363             :   }
    9364          32 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9365          64 :   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
    9366          32 :   if (!SWIG_IsOK(ecode2)) {
    9367           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointList_GetBreakpointAtIndex" "', argument " "2"" of type '" "size_t""'");
    9368             :   } 
    9369          32 :   arg2 = static_cast< size_t >(val2);
    9370             :   {
    9371          64 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9372          32 :     result = (arg1)->GetBreakpointAtIndex(arg2);
    9373          32 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9374             :   }
    9375          32 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(static_cast< const lldb::SBBreakpoint& >(result))), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
    9376          32 :   return resultobj;
    9377           0 : fail:
    9378             :   return NULL;
    9379             : }
    9380             : 
    9381             : 
    9382          30 : SWIGINTERN PyObject *_wrap_SBBreakpointList_FindBreakpointByID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9383          30 :   PyObject *resultobj = 0;
    9384          30 :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9385             :   lldb::break_id_t arg2 ;
    9386          30 :   void *argp1 = 0 ;
    9387          30 :   int res1 = 0 ;
    9388             :   int val2 ;
    9389          30 :   int ecode2 = 0 ;
    9390          30 :   PyObject * obj0 = 0 ;
    9391          30 :   PyObject * obj1 = 0 ;
    9392          60 :   lldb::SBBreakpoint result;
    9393             :   
    9394          30 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointList_FindBreakpointByID",&obj0,&obj1)) SWIG_fail;
    9395          30 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9396          30 :   if (!SWIG_IsOK(res1)) {
    9397           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_FindBreakpointByID" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9398             :   }
    9399          30 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9400          60 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    9401          30 :   if (!SWIG_IsOK(ecode2)) {
    9402           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointList_FindBreakpointByID" "', argument " "2"" of type '" "lldb::break_id_t""'");
    9403             :   } 
    9404          30 :   arg2 = static_cast< lldb::break_id_t >(val2);
    9405             :   {
    9406          60 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9407          30 :     result = (arg1)->FindBreakpointByID(arg2);
    9408          30 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9409             :   }
    9410          30 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(static_cast< const lldb::SBBreakpoint& >(result))), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
    9411          30 :   return resultobj;
    9412           0 : fail:
    9413             :   return NULL;
    9414             : }
    9415             : 
    9416             : 
    9417          38 : SWIGINTERN PyObject *_wrap_SBBreakpointList_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9418          38 :   PyObject *resultobj = 0;
    9419          38 :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9420          38 :   lldb::SBBreakpoint *arg2 = 0 ;
    9421          38 :   void *argp1 = 0 ;
    9422          38 :   int res1 = 0 ;
    9423          38 :   void *argp2 = 0 ;
    9424          38 :   int res2 = 0 ;
    9425          38 :   PyObject * obj0 = 0 ;
    9426          38 :   PyObject * obj1 = 0 ;
    9427             :   
    9428          38 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointList_Append",&obj0,&obj1)) SWIG_fail;
    9429          38 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9430          38 :   if (!SWIG_IsOK(res1)) {
    9431           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_Append" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9432             :   }
    9433          38 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9434          38 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
    9435          38 :   if (!SWIG_IsOK(res2)) {
    9436           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointList_Append" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9437             :   }
    9438          38 :   if (!argp2) {
    9439           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpointList_Append" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9440             :   }
    9441          38 :   arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
    9442             :   {
    9443          76 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9444          38 :     (arg1)->Append((lldb::SBBreakpoint const &)*arg2);
    9445          38 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9446             :   }
    9447          38 :   resultobj = SWIG_Py_Void();
    9448          38 :   return resultobj;
    9449           0 : fail:
    9450             :   return NULL;
    9451             : }
    9452             : 
    9453             : 
    9454           0 : SWIGINTERN PyObject *_wrap_SBBreakpointList_AppendIfUnique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9455           0 :   PyObject *resultobj = 0;
    9456           0 :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9457           0 :   lldb::SBBreakpoint *arg2 = 0 ;
    9458           0 :   void *argp1 = 0 ;
    9459           0 :   int res1 = 0 ;
    9460           0 :   void *argp2 = 0 ;
    9461           0 :   int res2 = 0 ;
    9462           0 :   PyObject * obj0 = 0 ;
    9463           0 :   PyObject * obj1 = 0 ;
    9464             :   bool result;
    9465             :   
    9466           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointList_AppendIfUnique",&obj0,&obj1)) SWIG_fail;
    9467           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9468           0 :   if (!SWIG_IsOK(res1)) {
    9469           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_AppendIfUnique" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9470             :   }
    9471           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9472           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
    9473           0 :   if (!SWIG_IsOK(res2)) {
    9474           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointList_AppendIfUnique" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9475             :   }
    9476           0 :   if (!argp2) {
    9477           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpointList_AppendIfUnique" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9478             :   }
    9479           0 :   arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
    9480             :   {
    9481           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9482           0 :     result = (bool)(arg1)->AppendIfUnique((lldb::SBBreakpoint const &)*arg2);
    9483           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9484             :   }
    9485           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9486           0 :   return resultobj;
    9487           0 : fail:
    9488             :   return NULL;
    9489             : }
    9490             : 
    9491             : 
    9492           0 : SWIGINTERN PyObject *_wrap_SBBreakpointList_AppendByID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9493           0 :   PyObject *resultobj = 0;
    9494           0 :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9495             :   lldb::break_id_t arg2 ;
    9496           0 :   void *argp1 = 0 ;
    9497           0 :   int res1 = 0 ;
    9498             :   int val2 ;
    9499           0 :   int ecode2 = 0 ;
    9500           0 :   PyObject * obj0 = 0 ;
    9501           0 :   PyObject * obj1 = 0 ;
    9502             :   
    9503           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointList_AppendByID",&obj0,&obj1)) SWIG_fail;
    9504           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9505           0 :   if (!SWIG_IsOK(res1)) {
    9506           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_AppendByID" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9507             :   }
    9508           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9509           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    9510           0 :   if (!SWIG_IsOK(ecode2)) {
    9511           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointList_AppendByID" "', argument " "2"" of type '" "lldb::break_id_t""'");
    9512             :   } 
    9513           0 :   arg2 = static_cast< lldb::break_id_t >(val2);
    9514             :   {
    9515           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9516           0 :     (arg1)->AppendByID(arg2);
    9517           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9518             :   }
    9519           0 :   resultobj = SWIG_Py_Void();
    9520           0 :   return resultobj;
    9521           0 : fail:
    9522             :   return NULL;
    9523             : }
    9524             : 
    9525             : 
    9526           8 : SWIGINTERN PyObject *_wrap_SBBreakpointList_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9527           8 :   PyObject *resultobj = 0;
    9528           8 :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9529           8 :   void *argp1 = 0 ;
    9530           8 :   int res1 = 0 ;
    9531           8 :   PyObject * obj0 = 0 ;
    9532             :   
    9533           8 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointList_Clear",&obj0)) SWIG_fail;
    9534           8 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9535           8 :   if (!SWIG_IsOK(res1)) {
    9536           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_Clear" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9537             :   }
    9538           8 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9539             :   {
    9540          16 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9541           8 :     (arg1)->Clear();
    9542           8 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9543             :   }
    9544           8 :   resultobj = SWIG_Py_Void();
    9545           8 :   return resultobj;
    9546           0 : fail:
    9547             :   return NULL;
    9548             : }
    9549             : 
    9550             : 
    9551         605 : SWIGINTERN PyObject *SBBreakpointList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9552             :   PyObject *obj;
    9553         605 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    9554        1210 :   SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBreakpointList, SWIG_NewClientData(obj));
    9555         605 :   return SWIG_Py_Void();
    9556             : }
    9557             : 
    9558           1 : SWIGINTERN PyObject *_wrap_new_SBBreakpointLocation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9559           1 :   PyObject *resultobj = 0;
    9560           1 :   lldb::SBBreakpointLocation *result = 0 ;
    9561             :   
    9562           1 :   if (!PyArg_ParseTuple(args,(char *)":new_SBBreakpointLocation")) SWIG_fail;
    9563             :   {
    9564           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9565           1 :     result = (lldb::SBBreakpointLocation *)new lldb::SBBreakpointLocation();
    9566           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9567             :   }
    9568           1 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_NEW |  0 );
    9569             :   return resultobj;
    9570           1 : fail:
    9571             :   return NULL;
    9572             : }
    9573             : 
    9574             : 
    9575           0 : SWIGINTERN PyObject *_wrap_new_SBBreakpointLocation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9576           0 :   PyObject *resultobj = 0;
    9577           0 :   lldb::SBBreakpointLocation *arg1 = 0 ;
    9578           0 :   void *argp1 = 0 ;
    9579           0 :   int res1 = 0 ;
    9580           0 :   PyObject * obj0 = 0 ;
    9581           0 :   lldb::SBBreakpointLocation *result = 0 ;
    9582             :   
    9583           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBBreakpointLocation",&obj0)) SWIG_fail;
    9584           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBBreakpointLocation,  0  | 0);
    9585           0 :   if (!SWIG_IsOK(res1)) {
    9586           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpointLocation" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const &""'"); 
    9587             :   }
    9588           0 :   if (!argp1) {
    9589           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBBreakpointLocation" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const &""'"); 
    9590             :   }
    9591           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9592             :   {
    9593           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9594           0 :     result = (lldb::SBBreakpointLocation *)new lldb::SBBreakpointLocation((lldb::SBBreakpointLocation const &)*arg1);
    9595           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9596             :   }
    9597           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_NEW |  0 );
    9598             :   return resultobj;
    9599             : fail:
    9600             :   return NULL;
    9601             : }
    9602             : 
    9603             : 
    9604           1 : SWIGINTERN PyObject *_wrap_new_SBBreakpointLocation(PyObject *self, PyObject *args) {
    9605             :   Py_ssize_t argc;
    9606           1 :   PyObject *argv[2] = {
    9607             :     0
    9608             :   };
    9609             :   Py_ssize_t ii;
    9610             :   
    9611           1 :   if (!PyTuple_Check(args)) SWIG_fail;
    9612           1 :   argc = args ? PyObject_Length(args) : 0;
    9613           1 :   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    9614           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    9615             :   }
    9616           1 :   if (argc == 0) {
    9617           1 :     return _wrap_new_SBBreakpointLocation__SWIG_0(self, args);
    9618             :   }
    9619           0 :   if (argc == 1) {
    9620             :     int _v;
    9621           0 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBBreakpointLocation, 0);
    9622           0 :     _v = SWIG_CheckState(res);
    9623             :     if (_v) {
    9624           0 :       return _wrap_new_SBBreakpointLocation__SWIG_1(self, args);
    9625             :     }
    9626             :   }
    9627             :   
    9628           0 : fail:
    9629           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SBBreakpointLocation'.\n"
    9630             :     "  Possible C/C++ prototypes are:\n"
    9631             :     "    lldb::SBBreakpointLocation::SBBreakpointLocation()\n"
    9632             :     "    lldb::SBBreakpointLocation::SBBreakpointLocation(lldb::SBBreakpointLocation const &)\n");
    9633           0 :   return 0;
    9634             : }
    9635             : 
    9636             : 
    9637         127 : SWIGINTERN PyObject *_wrap_delete_SBBreakpointLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9638         127 :   PyObject *resultobj = 0;
    9639         127 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9640         127 :   void *argp1 = 0 ;
    9641         127 :   int res1 = 0 ;
    9642         127 :   PyObject * obj0 = 0 ;
    9643             :   
    9644         127 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBBreakpointLocation",&obj0)) SWIG_fail;
    9645         127 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_DISOWN |  0 );
    9646         127 :   if (!SWIG_IsOK(res1)) {
    9647           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBreakpointLocation" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9648             :   }
    9649         127 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9650             :   {
    9651         254 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9652         127 :     delete arg1;
    9653         127 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9654             :   }
    9655         127 :   resultobj = SWIG_Py_Void();
    9656         127 :   return resultobj;
    9657           0 : fail:
    9658             :   return NULL;
    9659             : }
    9660             : 
    9661             : 
    9662           0 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9663           0 :   PyObject *resultobj = 0;
    9664           0 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9665           0 :   void *argp1 = 0 ;
    9666           0 :   int res1 = 0 ;
    9667           0 :   PyObject * obj0 = 0 ;
    9668             :   lldb::break_id_t result;
    9669             :   
    9670           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetID",&obj0)) SWIG_fail;
    9671           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9672           0 :   if (!SWIG_IsOK(res1)) {
    9673           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetID" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9674             :   }
    9675           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9676             :   {
    9677           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9678           0 :     result = (lldb::break_id_t)(arg1)->GetID();
    9679           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9680             :   }
    9681           0 :   resultobj = SWIG_From_int(static_cast< int >(result));
    9682           0 :   return resultobj;
    9683           0 : fail:
    9684             :   return NULL;
    9685             : }
    9686             : 
    9687             : 
    9688          16 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9689          16 :   PyObject *resultobj = 0;
    9690          16 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9691          16 :   void *argp1 = 0 ;
    9692          16 :   int res1 = 0 ;
    9693          16 :   PyObject * obj0 = 0 ;
    9694             :   bool result;
    9695             :   
    9696          16 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_IsValid",&obj0)) SWIG_fail;
    9697          16 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9698          16 :   if (!SWIG_IsOK(res1)) {
    9699           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_IsValid" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const *""'"); 
    9700             :   }
    9701          16 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9702             :   {
    9703          32 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9704          16 :     result = (bool)((lldb::SBBreakpointLocation const *)arg1)->IsValid();
    9705          16 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9706             :   }
    9707          16 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9708          16 :   return resultobj;
    9709           0 : fail:
    9710             :   return NULL;
    9711             : }
    9712             : 
    9713             : 
    9714          70 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9715          70 :   PyObject *resultobj = 0;
    9716          70 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9717          70 :   void *argp1 = 0 ;
    9718          70 :   int res1 = 0 ;
    9719          70 :   PyObject * obj0 = 0 ;
    9720         140 :   lldb::SBAddress result;
    9721             :   
    9722          70 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetAddress",&obj0)) SWIG_fail;
    9723          70 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9724          70 :   if (!SWIG_IsOK(res1)) {
    9725           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetAddress" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9726             :   }
    9727          70 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9728             :   {
    9729         140 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9730          70 :     result = (arg1)->GetAddress();
    9731          70 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9732             :   }
    9733          70 :   resultobj = SWIG_NewPointerObj((new lldb::SBAddress(static_cast< const lldb::SBAddress& >(result))), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
    9734          70 :   return resultobj;
    9735           0 : fail:
    9736             :   return NULL;
    9737             : }
    9738             : 
    9739             : 
    9740          13 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetLoadAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9741          13 :   PyObject *resultobj = 0;
    9742          13 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9743          13 :   void *argp1 = 0 ;
    9744          13 :   int res1 = 0 ;
    9745          13 :   PyObject * obj0 = 0 ;
    9746             :   lldb::addr_t result;
    9747             :   
    9748          13 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetLoadAddress",&obj0)) SWIG_fail;
    9749          13 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9750          13 :   if (!SWIG_IsOK(res1)) {
    9751           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetLoadAddress" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9752             :   }
    9753          13 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9754             :   {
    9755          26 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9756          13 :     result = (lldb::addr_t)(arg1)->GetLoadAddress();
    9757          13 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9758             :   }
    9759          13 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    9760          13 :   return resultobj;
    9761           0 : fail:
    9762             :   return NULL;
    9763             : }
    9764             : 
    9765             : 
    9766           1 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9767           1 :   PyObject *resultobj = 0;
    9768           1 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9769             :   bool arg2 ;
    9770           1 :   void *argp1 = 0 ;
    9771           1 :   int res1 = 0 ;
    9772             :   bool val2 ;
    9773           1 :   int ecode2 = 0 ;
    9774           1 :   PyObject * obj0 = 0 ;
    9775           1 :   PyObject * obj1 = 0 ;
    9776             :   
    9777           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetEnabled",&obj0,&obj1)) SWIG_fail;
    9778           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9779           1 :   if (!SWIG_IsOK(res1)) {
    9780           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetEnabled" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9781             :   }
    9782           1 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9783           2 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    9784             :   if (!SWIG_IsOK(ecode2)) {
    9785           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointLocation_SetEnabled" "', argument " "2"" of type '" "bool""'");
    9786             :   } 
    9787           1 :   arg2 = static_cast< bool >(val2);
    9788             :   {
    9789           2 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9790           1 :     (arg1)->SetEnabled(arg2);
    9791           1 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9792             :   }
    9793           1 :   resultobj = SWIG_Py_Void();
    9794           1 :   return resultobj;
    9795           0 : fail:
    9796             :   return NULL;
    9797             : }
    9798             : 
    9799             : 
    9800          10 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9801          10 :   PyObject *resultobj = 0;
    9802          10 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9803          10 :   void *argp1 = 0 ;
    9804          10 :   int res1 = 0 ;
    9805          10 :   PyObject * obj0 = 0 ;
    9806             :   bool result;
    9807             :   
    9808          10 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_IsEnabled",&obj0)) SWIG_fail;
    9809          10 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9810          10 :   if (!SWIG_IsOK(res1)) {
    9811           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_IsEnabled" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9812             :   }
    9813          10 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9814             :   {
    9815          20 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9816          10 :     result = (bool)(arg1)->IsEnabled();
    9817          10 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9818             :   }
    9819          10 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9820          10 :   return resultobj;
    9821           0 : fail:
    9822             :   return NULL;
    9823             : }
    9824             : 
    9825             : 
    9826           0 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetHitCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9827           0 :   PyObject *resultobj = 0;
    9828           0 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9829           0 :   void *argp1 = 0 ;
    9830           0 :   int res1 = 0 ;
    9831           0 :   PyObject * obj0 = 0 ;
    9832             :   uint32_t result;
    9833             :   
    9834           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetHitCount",&obj0)) SWIG_fail;
    9835           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9836           0 :   if (!SWIG_IsOK(res1)) {
    9837           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetHitCount" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9838             :   }
    9839           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9840             :   {
    9841           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9842           0 :     result = (uint32_t)(arg1)->GetHitCount();
    9843           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9844             :   }
    9845           0 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    9846           0 :   return resultobj;
    9847           0 : fail:
    9848             :   return NULL;
    9849             : }
    9850             : 
    9851             : 
    9852           4 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetIgnoreCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9853           4 :   PyObject *resultobj = 0;
    9854           4 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9855           4 :   void *argp1 = 0 ;
    9856           4 :   int res1 = 0 ;
    9857           4 :   PyObject * obj0 = 0 ;
    9858             :   uint32_t result;
    9859             :   
    9860           4 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetIgnoreCount",&obj0)) SWIG_fail;
    9861           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9862           4 :   if (!SWIG_IsOK(res1)) {
    9863           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9864             :   }
    9865           4 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9866             :   {
    9867           8 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9868           4 :     result = (uint32_t)(arg1)->GetIgnoreCount();
    9869           4 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9870             :   }
    9871           4 :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    9872           4 :   return resultobj;
    9873           0 : fail:
    9874             :   return NULL;
    9875             : }
    9876             : 
    9877             : 
    9878           2 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetIgnoreCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9879           2 :   PyObject *resultobj = 0;
    9880           2 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9881             :   uint32_t arg2 ;
    9882           2 :   void *argp1 = 0 ;
    9883           2 :   int res1 = 0 ;
    9884             :   unsigned int val2 ;
    9885           2 :   int ecode2 = 0 ;
    9886           2 :   PyObject * obj0 = 0 ;
    9887           2 :   PyObject * obj1 = 0 ;
    9888             :   
    9889           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetIgnoreCount",&obj0,&obj1)) SWIG_fail;
    9890           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9891           2 :   if (!SWIG_IsOK(res1)) {
    9892           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9893             :   }
    9894           2 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9895           4 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    9896           2 :   if (!SWIG_IsOK(ecode2)) {
    9897           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointLocation_SetIgnoreCount" "', argument " "2"" of type '" "uint32_t""'");
    9898             :   } 
    9899           2 :   arg2 = static_cast< uint32_t >(val2);
    9900             :   {
    9901           4 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9902           2 :     (arg1)->SetIgnoreCount(arg2);
    9903           2 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9904             :   }
    9905           2 :   resultobj = SWIG_Py_Void();
    9906           2 :   return resultobj;
    9907           0 : fail:
    9908             :   return NULL;
    9909             : }
    9910             : 
    9911             : 
    9912          15 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9913          15 :   PyObject *resultobj = 0;
    9914          15 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9915          15 :   char *arg2 = (char *) 0 ;
    9916          15 :   void *argp1 = 0 ;
    9917          15 :   int res1 = 0 ;
    9918             :   int res2 ;
    9919          15 :   char *buf2 = 0 ;
    9920          15 :   int alloc2 = 0 ;
    9921          15 :   PyObject * obj0 = 0 ;
    9922          15 :   PyObject * obj1 = 0 ;
    9923             :   
    9924          15 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetCondition",&obj0,&obj1)) SWIG_fail;
    9925          15 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9926          15 :   if (!SWIG_IsOK(res1)) {
    9927           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetCondition" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9928             :   }
    9929          15 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9930          15 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    9931          15 :   if (!SWIG_IsOK(res2)) {
    9932           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetCondition" "', argument " "2"" of type '" "char const *""'");
    9933             :   }
    9934          15 :   arg2 = reinterpret_cast< char * >(buf2);
    9935             :   {
    9936          30 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9937          15 :     (arg1)->SetCondition((char const *)arg2);
    9938          15 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9939             :   }
    9940          15 :   resultobj = SWIG_Py_Void();
    9941          15 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    9942             :   return resultobj;
    9943           0 : fail:
    9944           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    9945             :   return NULL;
    9946             : }
    9947             : 
    9948             : 
    9949          11 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9950          11 :   PyObject *resultobj = 0;
    9951          11 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9952          11 :   void *argp1 = 0 ;
    9953          11 :   int res1 = 0 ;
    9954          11 :   PyObject * obj0 = 0 ;
    9955          11 :   char *result = 0 ;
    9956             :   
    9957          11 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetCondition",&obj0)) SWIG_fail;
    9958          11 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9959          11 :   if (!SWIG_IsOK(res1)) {
    9960           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetCondition" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9961             :   }
    9962          11 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9963             :   {
    9964          22 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9965          11 :     result = (char *)(arg1)->GetCondition();
    9966          11 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9967             :   }
    9968          11 :   resultobj = SWIG_FromCharPtr((const char *)result);
    9969          11 :   return resultobj;
    9970           0 : fail:
    9971             :   return NULL;
    9972             : }
    9973             : 
    9974             : 
    9975           0 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetAutoContinue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9976           0 :   PyObject *resultobj = 0;
    9977           0 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9978           0 :   void *argp1 = 0 ;
    9979           0 :   int res1 = 0 ;
    9980           0 :   PyObject * obj0 = 0 ;
    9981             :   bool result;
    9982             :   
    9983           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetAutoContinue",&obj0)) SWIG_fail;
    9984           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9985           0 :   if (!SWIG_IsOK(res1)) {
    9986           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9987             :   }
    9988           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9989             :   {
    9990           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9991           0 :     result = (bool)(arg1)->GetAutoContinue();
    9992           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
    9993             :   }
    9994           0 :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9995           0 :   return resultobj;
    9996           0 : fail:
    9997             :   return NULL;
    9998             : }
    9999             : 
   10000             : 
   10001           0 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetAutoContinue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10002           0 :   PyObject *resultobj = 0;
   10003           0 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10004             :   bool arg2 ;
   10005           0 :   void *argp1 = 0 ;
   10006           0 :   int res1 = 0 ;
   10007             :   bool val2 ;
   10008           0 :   int ecode2 = 0 ;
   10009           0 :   PyObject * obj0 = 0 ;
   10010           0 :   PyObject * obj1 = 0 ;
   10011             :   
   10012           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetAutoContinue",&obj0,&obj1)) SWIG_fail;
   10013           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10014           0 :   if (!SWIG_IsOK(res1)) {
   10015           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10016             :   }
   10017           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10018           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
   10019             :   if (!SWIG_IsOK(ecode2)) {
   10020           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointLocation_SetAutoContinue" "', argument " "2"" of type '" "bool""'");
   10021             :   } 
   10022           0 :   arg2 = static_cast< bool >(val2);
   10023             :   {
   10024           0 :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10025           0 :     (arg1)->SetAutoContinue(arg2);
   10026           0 :     SWIG_PYTHON_THREAD_END_ALLOW;
   10027             :   }
   10028           0 :   resultobj = SWIG_Py_Void();
   10029           0 :   return resultobj;
   10030           0 : fail:
   10031             :   return NULL;
   10032             : }
   10033             : 
   10034             : 
   10035           0 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10036           0 :   PyObject *resultobj = 0;
   10037           0 :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10038           0 :   char *arg2 = (char *) 0 ;
   10039           0 :   void *argp1 = 0 ;
   10040           0 :   int res1 = 0 ;
   10041             :   int res2 ;
   10042           0 :   char *buf2 = 0 ;
   10043           0 :   int alloc2 = 0 ;
   10044           0 :   PyObject * obj0 = 0 ;
   10045           0 :   PyObject * obj1 = 0 ;
   10046             :   
   10047           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetScriptCallbackFunction",&obj0,&obj1)) SWIG_fail;
   10048           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10049           0 :   if (!SWIG_IsOK(res1)) {
   10050           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetScriptCallbackFunction" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10051             :   }
   10052           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10053