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: 11227 33644 33.4 %
Date: 2018-09-23 13:06:45 Functions: 891 2201 40.5 %
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        4443 : template<typename T> class SwigValueWrapper {
      23             :   struct SwigMovePointer {
      24             :     T *ptr;
      25        8886 :     SwigMovePointer(T *p) : ptr(p) { }
      26        8886 :     ~SwigMovePointer() { delete ptr; }
      27           0 :     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             :   SwigValueWrapper() : pointer(0) { }
      33        4443 :   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
      34           0 :   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             :   int equiv = 1;
     416           0 :   const char* te = tb + strlen(tb);
     417             :   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          15 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
     442          15 :   if (ty) {
     443          15 :     swig_cast_info *iter = ty->cast;
     444          30 :     while (iter) {
     445          15 :       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          15 :       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           0 :   if (!type) return NULL;
     532         958 :   if (type->str != NULL) {
     533             :     const char *last_name = type->str;
     534             :     const char *s;
     535       17244 :     for (s = type->str; *s; s++)
     536       16286 :       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           0 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
     548           0 :   swig_cast_info *cast = ti->cast;
     549             :   /* if (ti->clientdata == clientdata) return; */
     550           0 :   ti->clientdata = clientdata;
     551             : 
     552           0 :   while (cast) {
     553           0 :     if (!cast->converter) {
     554           0 :       swig_type_info *tc = cast->type;
     555           0 :       if (!tc->clientdata) {
     556           0 :         SWIG_TypeClientData(tc, clientdata);
     557             :       }
     558             :     }
     559           0 :     cast = cast->next;
     560             :   }
     561           0 : }
     562             : SWIGRUNTIME void
     563             : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
     564       48900 :   SWIG_TypeClientData(ti, clientdata);
     565       48900 :   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          46 : SWIG_MangledTypeQueryModule(swig_module_info *start,
     578             :                             swig_module_info *end,
     579             :                             const char *name) {
     580             :   swig_module_info *iter = start;
     581             :   do {
     582          46 :     if (iter->size) {
     583             :       size_t l = 0;
     584          46 :       size_t r = iter->size - 1;
     585             :       do {
     586             :         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
     587         276 :         size_t i = (l + r) >> 1;
     588         276 :         const char *iname = iter->types[i]->name;
     589         276 :         if (iname) {
     590         276 :           int compare = strcmp(name, iname);
     591         276 :           if (compare == 0) {
     592          46 :             return iter->types[i];
     593         230 :           } else if (compare < 0) {
     594         230 :             if (i) {
     595         230 :               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         230 :       } 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          46 : 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          46 :   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
     627          46 :   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             :       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           0 :           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             :   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             :   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             :   char *r = buff;
     697           0 :   if ((2*sizeof(void *) + 2) > bsz) return 0;
     698           0 :   *(r++) = '_';
     699             :   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             :   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             :   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           0 :   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             :   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             :          ~SWIG_Python_Thread_Block() { end(); }
    1077             :        };
    1078             :        class SWIG_Python_Thread_Allow {
    1079             :          bool status;
    1080             :          PyThreadState *save;
    1081             :        public:
    1082      214506 :          void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
    1083       26287 :          SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
    1084             :          ~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             :   SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    1242           0 :   PyErr_SetString(errtype, msg);
    1243             :   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      464868 : 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      464868 :   PyDict_SetItemString(d, name, obj);
    1279             : #endif
    1280      464868 :   Py_DECREF(obj);                            
    1281      464868 : }
    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             :   PyObject *none = Py_None;
    1447           0 :   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       48900 : SwigPyClientData_New(PyObject* obj)
    1480             : {
    1481       48900 :   if (!obj) {
    1482             :     return 0;
    1483             :   } else {
    1484       48900 :     SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    1485             :     /* the klass element */
    1486       48900 :     data->klass = obj;
    1487       48900 :     Py_INCREF(data->klass);
    1488             :     /* the newraw method and newargs arguments used to create a new raw instance */
    1489       48900 :     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       48900 :       data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
    1498             : #endif
    1499       48900 :       if (data->newraw) {
    1500       48900 :         Py_INCREF(data->newraw);
    1501       48900 :         data->newargs = PyTuple_New(1);
    1502       48900 :         PyTuple_SetItem(data->newargs, 0, obj);
    1503             :       } else {
    1504           0 :         data->newargs = obj;
    1505             :       }
    1506       48900 :       Py_INCREF(data->newargs);
    1507             :     }
    1508             :     /* the destroy method, aka as the C++ delete method */
    1509       48900 :     data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
    1510       48900 :     if (PyErr_Occurred()) {
    1511           0 :       PyErr_Clear();
    1512           0 :       data->destroy = 0;
    1513             :     }
    1514       48900 :     if (data->destroy) {
    1515             :       int flags;
    1516       48900 :       Py_INCREF(data->destroy);
    1517       48900 :       flags = PyCFunction_GET_FLAGS(data->destroy);
    1518             : #ifdef METH_O
    1519       48900 :       data->delargs = !(flags & (METH_O));
    1520             : #else
    1521             :       data->delargs = 0;
    1522             : #endif
    1523             :     } else {
    1524           0 :       data->delargs = 0;
    1525             :     }
    1526       48900 :     data->implicitconv = 0;
    1527       48900 :     data->pytype = 0;
    1528       48900 :     return data;
    1529             :   }
    1530             : }
    1531             : 
    1532             : SWIGRUNTIME void 
    1533       48900 : SwigPyClientData_Del(SwigPyClientData *data) {
    1534       48900 :   Py_XDECREF(data->newraw);
    1535       48900 :   Py_XDECREF(data->newargs);
    1536       48900 :   Py_XDECREF(data->destroy);
    1537       48900 : }
    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             :   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             :       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         958 : SwigPyObject_repr(SwigPyObject *v)
    1612             : #else
    1613             : SwigPyObject_repr(SwigPyObject *v, PyObject *args)
    1614             : #endif
    1615             : {
    1616         958 :   const char *name = SWIG_TypePrettyName(v->ty);
    1617         958 :   PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
    1618         958 :   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         958 :   return repr;  
    1634             : }
    1635             : 
    1636             : /* We need a version taking two PyObject* parameters so it's a valid
    1637             :  * PyCFunction to use in swigobject_methods[]. */
    1638             : SWIGRUNTIME PyObject *
    1639           0 : SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
    1640             : {
    1641           0 :   return SwigPyObject_repr((SwigPyObject*)v);
    1642             : }
    1643             : 
    1644             : SWIGRUNTIME int
    1645           0 : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
    1646             : {
    1647           0 :   void *i = v->ptr;
    1648           0 :   void *j = w->ptr;
    1649           0 :   return (i < j) ? -1 : ((i > j) ? 1 : 0);
    1650             : }
    1651             : 
    1652             : /* Added for Python 3.x, would it also be useful for Python 2.x? */
    1653             : SWIGRUNTIME PyObject*
    1654           0 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
    1655             : {
    1656             :   PyObject* res;
    1657           0 :   if( op != Py_EQ && op != Py_NE ) {
    1658           0 :     Py_INCREF(Py_NotImplemented);
    1659           0 :     return Py_NotImplemented;
    1660             :   }
    1661           0 :   res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
    1662           0 :   return res;  
    1663             : }
    1664             : 
    1665             : 
    1666             : SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
    1667             : 
    1668             : #ifdef SWIGPYTHON_BUILTIN
    1669             : static swig_type_info *SwigPyObject_stype = 0;
    1670             : SWIGRUNTIME PyTypeObject*
    1671             : SwigPyObject_type(void) {
    1672             :     SwigPyClientData *cd;
    1673             :     assert(SwigPyObject_stype);
    1674             :     cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    1675             :     assert(cd);
    1676             :     assert(cd->pytype);
    1677             :     return cd->pytype;
    1678             : }
    1679             : #else
    1680             : SWIGRUNTIME PyTypeObject*
    1681     1002133 : SwigPyObject_type(void) {
    1682     1002133 :   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
    1683     1002133 :   return type;
    1684             : }
    1685             : #endif
    1686             : 
    1687             : SWIGRUNTIMEINLINE int
    1688           0 : SwigPyObject_Check(PyObject *op) {
    1689             : #ifdef SWIGPYTHON_BUILTIN
    1690             :   PyTypeObject *target_tp = SwigPyObject_type();
    1691             :   if (PyType_IsSubtype(op->ob_type, target_tp))
    1692             :     return 1;
    1693             :   return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
    1694             : #else
    1695           0 :   return (Py_TYPE(op) == SwigPyObject_type())
    1696           0 :     || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
    1697             : #endif
    1698             : }
    1699             : 
    1700             : SWIGRUNTIME PyObject *
    1701             : SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
    1702             : 
    1703             : SWIGRUNTIME void
    1704      173792 : SwigPyObject_dealloc(PyObject *v)
    1705             : {
    1706             :   SwigPyObject *sobj = (SwigPyObject *) v;
    1707      173792 :   PyObject *next = sobj->next;
    1708      173792 :   if (sobj->own == SWIG_POINTER_OWN) {
    1709       86857 :     swig_type_info *ty = sobj->ty;
    1710       86857 :     SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    1711       86857 :     PyObject *destroy = data ? data->destroy : 0;
    1712       86857 :     if (destroy) {
    1713             :       /* destroy is always a VARARGS method */
    1714             :       PyObject *res;
    1715             : 
    1716             :       /* PyObject_CallFunction() has the potential to silently drop
    1717             :          the active active exception.  In cases of unnamed temporary
    1718             :          variable or where we just finished iterating over a generator
    1719             :          StopIteration will be active right now, and this needs to
    1720             :          remain true upon return from SwigPyObject_dealloc.  So save
    1721             :          and restore. */
    1722             :       
    1723       86857 :       PyObject *val = NULL, *type = NULL, *tb = NULL;
    1724       86857 :       PyErr_Fetch(&val, &type, &tb);
    1725             : 
    1726       86857 :       if (data->delargs) {
    1727             :         /* we need to create a temporary object to carry the destroy operation */
    1728       86857 :         PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
    1729       86857 :         res = SWIG_Python_CallFunctor(destroy, tmp);
    1730       86857 :         Py_DECREF(tmp);
    1731             :       } else {
    1732           0 :         PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
    1733           0 :         PyObject *mself = PyCFunction_GET_SELF(destroy);
    1734           0 :         res = ((*meth)(mself, v));
    1735             :       }
    1736       86857 :       if (!res)
    1737           0 :         PyErr_WriteUnraisable(destroy);
    1738             : 
    1739       86857 :       PyErr_Restore(val, type, tb);
    1740             : 
    1741       86857 :       Py_XDECREF(res);
    1742             :     } 
    1743             : #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    1744             :     else {
    1745             :       const char *name = SWIG_TypePrettyName(ty);
    1746           0 :       printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    1747             :     }
    1748             : #endif
    1749             :   } 
    1750      173792 :   Py_XDECREF(next);
    1751      173792 :   PyObject_DEL(v);
    1752      173792 : }
    1753             : 
    1754             : SWIGRUNTIME PyObject* 
    1755           0 : SwigPyObject_append(PyObject* v, PyObject* next)
    1756             : {
    1757             :   SwigPyObject *sobj = (SwigPyObject *) v;
    1758             : #ifndef METH_O
    1759             :   PyObject *tmp = 0;
    1760             :   if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
    1761             :   next = tmp;
    1762             : #endif
    1763           0 :   if (!SwigPyObject_Check(next)) {
    1764           0 :     PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    1765           0 :     return NULL;
    1766             :   }
    1767           0 :   sobj->next = next;
    1768           0 :   Py_INCREF(next);
    1769           0 :   return SWIG_Py_Void();
    1770             : }
    1771             : 
    1772             : SWIGRUNTIME PyObject* 
    1773           0 : SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1774             : {
    1775             :   SwigPyObject *sobj = (SwigPyObject *) v;
    1776           0 :   if (sobj->next) {    
    1777           0 :     Py_INCREF(sobj->next);
    1778           0 :     return sobj->next;
    1779             :   } else {
    1780           0 :     return SWIG_Py_Void();
    1781             :   }
    1782             : }
    1783             : 
    1784             : SWIGINTERN PyObject*
    1785             : #ifdef METH_NOARGS
    1786             : SwigPyObject_disown(PyObject *v)
    1787             : #else
    1788             : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1789             : #endif
    1790             : {
    1791             :   SwigPyObject *sobj = (SwigPyObject *)v;
    1792           0 :   sobj->own = 0;
    1793             :   return SWIG_Py_Void();
    1794             : }
    1795             : 
    1796             : SWIGINTERN PyObject*
    1797             : #ifdef METH_NOARGS
    1798             : SwigPyObject_acquire(PyObject *v)
    1799             : #else
    1800             : SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1801             : #endif
    1802             : {
    1803             :   SwigPyObject *sobj = (SwigPyObject *)v;
    1804           0 :   sobj->own = SWIG_POINTER_OWN;
    1805             :   return SWIG_Py_Void();
    1806             : }
    1807             : 
    1808             : #ifdef METH_NOARGS
    1809             : static PyObject*
    1810           0 : SwigPyObject_disown2(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1811             : {
    1812           0 :   return SwigPyObject_disown(v);
    1813             : }
    1814             : 
    1815             : static PyObject*
    1816           0 : SwigPyObject_acquire2(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
    1817             : {
    1818           0 :   return SwigPyObject_acquire(v);
    1819             : }
    1820             : #endif
    1821             : 
    1822             : SWIGINTERN PyObject*
    1823           0 : SwigPyObject_own(PyObject *v, PyObject *args)
    1824             : {
    1825           0 :   PyObject *val = 0;
    1826             : #if (PY_VERSION_HEX < 0x02020000)
    1827             :   if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
    1828             : #elif (PY_VERSION_HEX < 0x02050000)
    1829             :   if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val)) 
    1830             : #else
    1831           0 :   if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) 
    1832             : #endif
    1833             :     {
    1834             :       return NULL;
    1835             :     } 
    1836             :   else
    1837             :     {
    1838             :       SwigPyObject *sobj = (SwigPyObject *)v;
    1839           0 :       PyObject *obj = PyBool_FromLong(sobj->own);
    1840           0 :       if (val) {
    1841             : #ifdef METH_NOARGS
    1842           0 :         if (PyObject_IsTrue(val)) {
    1843             :           SwigPyObject_acquire(v);
    1844             :         } else {
    1845             :           SwigPyObject_disown(v);
    1846             :         }
    1847             : #else
    1848             :         if (PyObject_IsTrue(val)) {
    1849             :           SwigPyObject_acquire(v,args);
    1850             :         } else {
    1851             :           SwigPyObject_disown(v,args);
    1852             :         }
    1853             : #endif
    1854             :       } 
    1855           0 :       return obj;
    1856             :     }
    1857             : }
    1858             : 
    1859             : #ifdef METH_O
    1860             : static PyMethodDef
    1861             : swigobject_methods[] = {
    1862             :   {(char *)"disown",  (PyCFunction)SwigPyObject_disown2, METH_NOARGS,  (char *)"releases ownership of the pointer"},
    1863             :   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire2,METH_NOARGS,  (char *)"acquires ownership of the pointer"},
    1864             :   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
    1865             :   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)"appends another 'this' object"},
    1866             :   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)"returns the next 'this' object"},
    1867             :   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr2,   METH_NOARGS,  (char *)"returns object representation"},
    1868             :   {0, 0, 0, 0}  
    1869             : };
    1870             : #else
    1871             : static PyMethodDef
    1872             : swigobject_methods[] = {
    1873             :   {(char *)"disown",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)"releases ownership of the pointer"},
    1874             :   {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)"acquires ownership of the pointer"},
    1875             :   {(char *)"own",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)"returns/sets ownership of the pointer"},
    1876             :   {(char *)"append",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)"appends another 'this' object"},
    1877             :   {(char *)"next",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)"returns the next 'this' object"},
    1878             :   {(char *)"__repr__",(PyCFunction)SwigPyObject_repr,    METH_VARARGS,  (char *)"returns object representation"},
    1879             :   {0, 0, 0, 0}  
    1880             : };
    1881             : #endif
    1882             : 
    1883             : #if PY_VERSION_HEX < 0x02020000
    1884             : SWIGINTERN PyObject *
    1885             : SwigPyObject_getattr(SwigPyObject *sobj,char *name)
    1886             : {
    1887             :   return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
    1888             : }
    1889             : #endif
    1890             : 
    1891             : SWIGRUNTIME PyTypeObject*
    1892         652 : SwigPyObject_TypeOnce(void) {
    1893             :   static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
    1894             : 
    1895             :   static PyNumberMethods SwigPyObject_as_number = {
    1896             :     (binaryfunc)0, /*nb_add*/
    1897             :     (binaryfunc)0, /*nb_subtract*/
    1898             :     (binaryfunc)0, /*nb_multiply*/
    1899             :     /* nb_divide removed in Python 3 */
    1900             : #if PY_VERSION_HEX < 0x03000000
    1901             :     (binaryfunc)0, /*nb_divide*/
    1902             : #endif
    1903             :     (binaryfunc)0, /*nb_remainder*/
    1904             :     (binaryfunc)0, /*nb_divmod*/
    1905             :     (ternaryfunc)0,/*nb_power*/
    1906             :     (unaryfunc)0,  /*nb_negative*/
    1907             :     (unaryfunc)0,  /*nb_positive*/
    1908             :     (unaryfunc)0,  /*nb_absolute*/
    1909             :     (inquiry)0,    /*nb_nonzero*/
    1910             :     0,             /*nb_invert*/
    1911             :     0,             /*nb_lshift*/
    1912             :     0,             /*nb_rshift*/
    1913             :     0,             /*nb_and*/
    1914             :     0,             /*nb_xor*/
    1915             :     0,             /*nb_or*/
    1916             : #if PY_VERSION_HEX < 0x03000000
    1917             :     0,   /*nb_coerce*/
    1918             : #endif
    1919             :     (unaryfunc)SwigPyObject_long, /*nb_int*/
    1920             : #if PY_VERSION_HEX < 0x03000000
    1921             :     (unaryfunc)SwigPyObject_long, /*nb_long*/
    1922             : #else
    1923             :     0, /*nb_reserved*/
    1924             : #endif
    1925             :     (unaryfunc)0,                 /*nb_float*/
    1926             : #if PY_VERSION_HEX < 0x03000000
    1927             :     (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    1928             :     (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
    1929             : #endif
    1930             : #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    1931             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
    1932             : #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    1933             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
    1934             : #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
    1935             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
    1936             : #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
    1937             :     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
    1938             : #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
    1939             :     0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
    1940             : #endif
    1941             :   };
    1942             : 
    1943             :   static PyTypeObject swigpyobject_type;
    1944             :   static int type_init = 0;
    1945         652 :   if (!type_init) {
    1946         652 :     const PyTypeObject tmp = {
    1947             : #if PY_VERSION_HEX >= 0x03000000
    1948             :       PyVarObject_HEAD_INIT(NULL, 0)
    1949             : #else
    1950             :       PyObject_HEAD_INIT(NULL)
    1951             :       0,                                    /* ob_size */
    1952             : #endif
    1953             :       (char *)"SwigPyObject",               /* tp_name */
    1954             :       sizeof(SwigPyObject),                 /* tp_basicsize */
    1955             :       0,                                    /* tp_itemsize */
    1956             :       (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
    1957             :       0,                                    /* tp_print */
    1958             : #if PY_VERSION_HEX < 0x02020000
    1959             :       (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */
    1960             : #else
    1961             :       (getattrfunc)0,                       /* tp_getattr */
    1962             : #endif
    1963             :       (setattrfunc)0,                       /* tp_setattr */
    1964             : #if PY_VERSION_HEX >= 0x03000000
    1965             :       0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
    1966             : #else
    1967             :       (cmpfunc)SwigPyObject_compare,        /* tp_compare */
    1968             : #endif
    1969             :       (reprfunc)SwigPyObject_repr,          /* tp_repr */
    1970             :       &SwigPyObject_as_number,              /* tp_as_number */
    1971             :       0,                                    /* tp_as_sequence */
    1972             :       0,                                    /* tp_as_mapping */
    1973             :       (hashfunc)0,                          /* tp_hash */
    1974             :       (ternaryfunc)0,                       /* tp_call */
    1975             :       0,                                    /* tp_str */
    1976             :       PyObject_GenericGetAttr,              /* tp_getattro */
    1977             :       0,                                    /* tp_setattro */
    1978             :       0,                                    /* tp_as_buffer */
    1979             :       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
    1980             :       swigobject_doc,                       /* tp_doc */
    1981             :       0,                                    /* tp_traverse */
    1982             :       0,                                    /* tp_clear */
    1983             :       (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
    1984             :       0,                                    /* tp_weaklistoffset */
    1985             : #if PY_VERSION_HEX >= 0x02020000
    1986             :       0,                                    /* tp_iter */
    1987             :       0,                                    /* tp_iternext */
    1988             :       swigobject_methods,                   /* tp_methods */
    1989             :       0,                                    /* tp_members */
    1990             :       0,                                    /* tp_getset */
    1991             :       0,                                    /* tp_base */
    1992             :       0,                                    /* tp_dict */
    1993             :       0,                                    /* tp_descr_get */
    1994             :       0,                                    /* tp_descr_set */
    1995             :       0,                                    /* tp_dictoffset */
    1996             :       0,                                    /* tp_init */
    1997             :       0,                                    /* tp_alloc */
    1998             :       0,                                    /* tp_new */
    1999             :       0,                                    /* tp_free */
    2000             :       0,                                    /* tp_is_gc */
    2001             :       0,                                    /* tp_bases */
    2002             :       0,                                    /* tp_mro */
    2003             :       0,                                    /* tp_cache */
    2004             :       0,                                    /* tp_subclasses */
    2005             :       0,                                    /* tp_weaklist */
    2006             : #endif
    2007             : #if PY_VERSION_HEX >= 0x02030000
    2008             :       0,                                    /* tp_del */
    2009             : #endif
    2010             : #if PY_VERSION_HEX >= 0x02060000
    2011             :       0,                                    /* tp_version_tag */
    2012             : #endif
    2013             : #if PY_VERSION_HEX >= 0x03040000
    2014             :       0,                                    /* tp_finalize */
    2015             : #endif
    2016             : #ifdef COUNT_ALLOCS
    2017             :       0,                                    /* tp_allocs */
    2018             :       0,                                    /* tp_frees */
    2019             :       0,                                    /* tp_maxalloc */
    2020             : #if PY_VERSION_HEX >= 0x02050000
    2021             :       0,                                    /* tp_prev */
    2022             : #endif
    2023             :       0                                     /* tp_next */
    2024             : #endif
    2025             :     };
    2026         652 :     swigpyobject_type = tmp;
    2027         652 :     type_init = 1;
    2028             : #if PY_VERSION_HEX < 0x02020000
    2029             :     swigpyobject_type.ob_type = &PyType_Type;
    2030             : #else
    2031         652 :     if (PyType_Ready(&swigpyobject_type) < 0)
    2032           0 :       return NULL;
    2033             : #endif
    2034             :   }
    2035             :   return &swigpyobject_type;
    2036             : }
    2037             : 
    2038             : SWIGRUNTIME PyObject *
    2039      177374 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
    2040             : {
    2041      177374 :   SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
    2042      177374 :   if (sobj) {
    2043      177374 :     sobj->ptr  = ptr;
    2044      177374 :     sobj->ty   = ty;
    2045      177374 :     sobj->own  = own;
    2046      177374 :     sobj->next = 0;
    2047             :   }
    2048      177374 :   return (PyObject *)sobj;
    2049             : }
    2050             : 
    2051             : /* -----------------------------------------------------------------------------
    2052             :  * Implements a simple Swig Packed type, and use it instead of string
    2053             :  * ----------------------------------------------------------------------------- */
    2054             : 
    2055             : typedef struct {
    2056             :   PyObject_HEAD
    2057             :   void *pack;
    2058             :   swig_type_info *ty;
    2059             :   size_t size;
    2060             : } SwigPyPacked;
    2061             : 
    2062             : SWIGRUNTIME int
    2063           0 : SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
    2064             : {
    2065             :   char result[SWIG_BUFFER_SIZE];
    2066           0 :   fputs("<Swig Packed ", fp); 
    2067           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    2068           0 :     fputs("at ", fp); 
    2069           0 :     fputs(result, fp); 
    2070             :   }
    2071           0 :   fputs(v->ty->name,fp); 
    2072           0 :   fputs(">", fp);
    2073           0 :   return 0; 
    2074             : }
    2075             :   
    2076             : SWIGRUNTIME PyObject *
    2077           0 : SwigPyPacked_repr(SwigPyPacked *v)
    2078             : {
    2079             :   char result[SWIG_BUFFER_SIZE];
    2080           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    2081           0 :     return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
    2082             :   } else {
    2083           0 :     return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
    2084             :   }  
    2085             : }
    2086             : 
    2087             : SWIGRUNTIME PyObject *
    2088           0 : SwigPyPacked_str(SwigPyPacked *v)
    2089             : {
    2090             :   char result[SWIG_BUFFER_SIZE];
    2091           0 :   if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    2092           0 :     return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
    2093             :   } else {
    2094           0 :     return SWIG_Python_str_FromChar(v->ty->name);
    2095             :   }  
    2096             : }
    2097             : 
    2098             : SWIGRUNTIME int
    2099           0 : SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
    2100             : {
    2101           0 :   size_t i = v->size;
    2102           0 :   size_t j = w->size;
    2103           0 :   int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
    2104           0 :   return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
    2105             : }
    2106             : 
    2107             : SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
    2108             : 
    2109             : SWIGRUNTIME PyTypeObject*
    2110           0 : SwigPyPacked_type(void) {
    2111           0 :   static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
    2112           0 :   return type;
    2113             : }
    2114             : 
    2115             : SWIGRUNTIMEINLINE int
    2116           0 : SwigPyPacked_Check(PyObject *op) {
    2117           0 :   return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
    2118           0 :     || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
    2119             : }
    2120             : 
    2121             : SWIGRUNTIME void
    2122           0 : SwigPyPacked_dealloc(PyObject *v)
    2123             : {
    2124           0 :   if (SwigPyPacked_Check(v)) {
    2125             :     SwigPyPacked *sobj = (SwigPyPacked *) v;
    2126           0 :     free(sobj->pack);
    2127             :   }
    2128           0 :   PyObject_DEL(v);
    2129           0 : }
    2130             : 
    2131             : SWIGRUNTIME PyTypeObject*
    2132           0 : SwigPyPacked_TypeOnce(void) {
    2133             :   static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
    2134             :   static PyTypeObject swigpypacked_type;
    2135             :   static int type_init = 0;
    2136           0 :   if (!type_init) {
    2137           0 :     const PyTypeObject tmp = {
    2138             : #if PY_VERSION_HEX>=0x03000000
    2139             :       PyVarObject_HEAD_INIT(NULL, 0)
    2140             : #else
    2141             :       PyObject_HEAD_INIT(NULL)
    2142             :       0,                                    /* ob_size */
    2143             : #endif
    2144             :       (char *)"SwigPyPacked",               /* tp_name */
    2145             :       sizeof(SwigPyPacked),                 /* tp_basicsize */
    2146             :       0,                                    /* tp_itemsize */
    2147             :       (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
    2148             :       (printfunc)SwigPyPacked_print,        /* tp_print */
    2149             :       (getattrfunc)0,                       /* tp_getattr */
    2150             :       (setattrfunc)0,                       /* tp_setattr */
    2151             : #if PY_VERSION_HEX>=0x03000000
    2152             :       0, /* tp_reserved in 3.0.1 */
    2153             : #else
    2154             :       (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
    2155             : #endif
    2156             :       (reprfunc)SwigPyPacked_repr,          /* tp_repr */
    2157             :       0,                                    /* tp_as_number */
    2158             :       0,                                    /* tp_as_sequence */
    2159             :       0,                                    /* tp_as_mapping */
    2160             :       (hashfunc)0,                          /* tp_hash */
    2161             :       (ternaryfunc)0,                       /* tp_call */
    2162             :       (reprfunc)SwigPyPacked_str,           /* tp_str */
    2163             :       PyObject_GenericGetAttr,              /* tp_getattro */
    2164             :       0,                                    /* tp_setattro */
    2165             :       0,                                    /* tp_as_buffer */
    2166             :       Py_TPFLAGS_DEFAULT,                   /* tp_flags */
    2167             :       swigpacked_doc,                       /* tp_doc */
    2168             :       0,                                    /* tp_traverse */
    2169             :       0,                                    /* tp_clear */
    2170             :       0,                                    /* tp_richcompare */
    2171             :       0,                                    /* tp_weaklistoffset */
    2172             : #if PY_VERSION_HEX >= 0x02020000
    2173             :       0,                                    /* tp_iter */
    2174             :       0,                                    /* tp_iternext */
    2175             :       0,                                    /* tp_methods */
    2176             :       0,                                    /* tp_members */
    2177             :       0,                                    /* tp_getset */
    2178             :       0,                                    /* tp_base */
    2179             :       0,                                    /* tp_dict */
    2180             :       0,                                    /* tp_descr_get */
    2181             :       0,                                    /* tp_descr_set */
    2182             :       0,                                    /* tp_dictoffset */
    2183             :       0,                                    /* tp_init */
    2184             :       0,                                    /* tp_alloc */
    2185             :       0,                                    /* tp_new */
    2186             :       0,                                    /* tp_free */
    2187             :       0,                                    /* tp_is_gc */
    2188             :       0,                                    /* tp_bases */
    2189             :       0,                                    /* tp_mro */
    2190             :       0,                                    /* tp_cache */
    2191             :       0,                                    /* tp_subclasses */
    2192             :       0,                                    /* tp_weaklist */
    2193             : #endif
    2194             : #if PY_VERSION_HEX >= 0x02030000
    2195             :       0,                                    /* tp_del */
    2196             : #endif
    2197             : #if PY_VERSION_HEX >= 0x02060000
    2198             :       0,                                    /* tp_version_tag */
    2199             : #endif
    2200             : #if PY_VERSION_HEX >= 0x03040000
    2201             :       0,                                    /* tp_finalize */
    2202             : #endif
    2203             : #ifdef COUNT_ALLOCS
    2204             :       0,                                    /* tp_allocs */
    2205             :       0,                                    /* tp_frees */
    2206             :       0,                                    /* tp_maxalloc */
    2207             : #if PY_VERSION_HEX >= 0x02050000
    2208             :       0,                                    /* tp_prev */
    2209             : #endif
    2210             :       0                                     /* tp_next */
    2211             : #endif
    2212             :     };
    2213           0 :     swigpypacked_type = tmp;
    2214           0 :     type_init = 1;
    2215             : #if PY_VERSION_HEX < 0x02020000
    2216             :     swigpypacked_type.ob_type = &PyType_Type;
    2217             : #else
    2218           0 :     if (PyType_Ready(&swigpypacked_type) < 0)
    2219           0 :       return NULL;
    2220             : #endif
    2221             :   }
    2222             :   return &swigpypacked_type;
    2223             : }
    2224             : 
    2225             : SWIGRUNTIME PyObject *
    2226           0 : SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
    2227             : {
    2228           0 :   SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
    2229           0 :   if (sobj) {
    2230           0 :     void *pack = malloc(size);
    2231           0 :     if (pack) {
    2232           0 :       memcpy(pack, ptr, size);
    2233           0 :       sobj->pack = pack;
    2234           0 :       sobj->ty   = ty;
    2235           0 :       sobj->size = size;
    2236             :     } else {
    2237           0 :       PyObject_DEL((PyObject *) sobj);
    2238             :       sobj = 0;
    2239             :     }
    2240             :   }
    2241           0 :   return (PyObject *) sobj;
    2242             : }
    2243             : 
    2244             : SWIGRUNTIME swig_type_info *
    2245             : SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
    2246             : {
    2247             :   if (SwigPyPacked_Check(obj)) {
    2248             :     SwigPyPacked *sobj = (SwigPyPacked *)obj;
    2249             :     if (sobj->size != size) return 0;
    2250             :     memcpy(ptr, sobj->pack, size);
    2251             :     return sobj->ty;
    2252             :   } else {
    2253             :     return 0;
    2254             :   }
    2255             : }
    2256             : 
    2257             : /* -----------------------------------------------------------------------------
    2258             :  * pointers/data manipulation
    2259             :  * ----------------------------------------------------------------------------- */
    2260             : 
    2261             : SWIGRUNTIMEINLINE PyObject *
    2262             : _SWIG_This(void)
    2263             : {
    2264             :     return SWIG_Python_str_FromChar("this");
    2265             : }
    2266             : 
    2267             : static PyObject *swig_this = NULL;
    2268             : 
    2269             : SWIGRUNTIME PyObject *
    2270             : SWIG_This(void)
    2271             : {
    2272      281122 :   if (swig_this == NULL)
    2273           0 :     swig_this = _SWIG_This();
    2274      281122 :   return swig_this;
    2275             : }
    2276             : 
    2277             : /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
    2278             : 
    2279             : /* TODO: I don't know how to implement the fast getset in Python 3 right now */
    2280             : #if PY_VERSION_HEX>=0x03000000
    2281             : #define SWIG_PYTHON_SLOW_GETSET_THIS 
    2282             : #endif
    2283             : 
    2284             : SWIGRUNTIME SwigPyObject *
    2285      367327 : SWIG_Python_GetSwigThis(PyObject *pyobj) 
    2286             : {
    2287             :   PyObject *obj;
    2288             : 
    2289      367327 :   if (SwigPyObject_Check(pyobj))
    2290             :     return (SwigPyObject *) pyobj;
    2291             : 
    2292             : #ifdef SWIGPYTHON_BUILTIN
    2293             :   (void)obj;
    2294             : # ifdef PyWeakref_CheckProxy
    2295             :   if (PyWeakref_CheckProxy(pyobj)) {
    2296             :     pyobj = PyWeakref_GET_OBJECT(pyobj);
    2297             :     if (pyobj && SwigPyObject_Check(pyobj))
    2298             :       return (SwigPyObject*) pyobj;
    2299             :   }
    2300             : # endif
    2301             :   return NULL;
    2302             : #else
    2303             : 
    2304             :   obj = 0;
    2305             : 
    2306             : #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
    2307      280470 :   if (PyInstance_Check(pyobj)) {
    2308           0 :     obj = _PyInstance_Lookup(pyobj, SWIG_This());      
    2309             :   } else {
    2310      280470 :     PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    2311      280470 :     if (dictptr != NULL) {
    2312      280058 :       PyObject *dict = *dictptr;
    2313      560116 :       obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    2314             :     } else {
    2315             : #ifdef PyWeakref_CheckProxy
    2316         412 :       if (PyWeakref_CheckProxy(pyobj)) {
    2317           0 :         PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
    2318           0 :         return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
    2319             :       }
    2320             : #endif
    2321         412 :       obj = PyObject_GetAttr(pyobj,SWIG_This());
    2322         412 :       if (obj) {
    2323           0 :         Py_DECREF(obj);
    2324             :       } else {
    2325         412 :         if (PyErr_Occurred()) PyErr_Clear();
    2326         412 :         return 0;
    2327             :       }
    2328             :     }
    2329             :   }
    2330             : #else
    2331             :   obj = PyObject_GetAttr(pyobj,SWIG_This());
    2332             :   if (obj) {
    2333             :     Py_DECREF(obj);
    2334             :   } else {
    2335             :     if (PyErr_Occurred()) PyErr_Clear();
    2336             :     return 0;
    2337             :   }
    2338             : #endif
    2339      280058 :   if (obj && !SwigPyObject_Check(obj)) {
    2340             :     /* a PyObject is called 'this', try to get the 'real this'
    2341             :        SwigPyObject from it */ 
    2342             :     return SWIG_Python_GetSwigThis(obj);
    2343             :   }
    2344             :   return (SwigPyObject *)obj;
    2345             : #endif
    2346             : }
    2347             : 
    2348             : /* Acquire a pointer value */
    2349             : 
    2350             : SWIGRUNTIME int
    2351             : SWIG_Python_AcquirePtr(PyObject *obj, int own) {
    2352             :   if (own == SWIG_POINTER_OWN) {
    2353             :     SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    2354             :     if (sobj) {
    2355             :       int oldown = sobj->own;
    2356             :       sobj->own = own;
    2357             :       return oldown;
    2358             :     }
    2359             :   }
    2360             :   return 0;
    2361             : }
    2362             : 
    2363             : /* Convert a pointer value */
    2364             : 
    2365             : SWIGRUNTIME int
    2366      367751 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
    2367             :   int res;
    2368             :   SwigPyObject *sobj;
    2369      367751 :   int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
    2370             : 
    2371      367751 :   if (!obj)
    2372             :     return SWIG_ERROR;
    2373      367751 :   if (obj == Py_None && !implicit_conv) {
    2374         424 :     if (ptr)
    2375         424 :       *ptr = 0;
    2376         424 :     return SWIG_OK;
    2377             :   }
    2378             : 
    2379             :   res = SWIG_ERROR;
    2380             : 
    2381      367327 :   sobj = SWIG_Python_GetSwigThis(obj);
    2382      367327 :   if (own)
    2383           0 :     *own = 0;
    2384      367342 :   while (sobj) {
    2385      366915 :     void *vptr = sobj->ptr;
    2386      366915 :     if (ty) {
    2387      366915 :       swig_type_info *to = sobj->ty;
    2388      366915 :       if (to == ty) {
    2389             :         /* no type cast needed */
    2390      366900 :         if (ptr) *ptr = vptr;
    2391             :         break;
    2392             :       } else {
    2393          15 :         swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
    2394          15 :         if (!tc) {
    2395          15 :           sobj = (SwigPyObject *)sobj->next;
    2396             :         } else {
    2397           0 :           if (ptr) {
    2398           0 :             int newmemory = 0;
    2399           0 :             *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
    2400           0 :             if (newmemory == SWIG_CAST_NEW_MEMORY) {
    2401             :               assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
    2402           0 :               if (own)
    2403           0 :                 *own = *own | SWIG_CAST_NEW_MEMORY;
    2404             :             }
    2405             :           }
    2406             :           break;
    2407             :         }
    2408             :       }
    2409             :     } else {
    2410           0 :       if (ptr) *ptr = vptr;
    2411             :       break;
    2412             :     }
    2413             :   }
    2414      367327 :   if (sobj) {
    2415      366900 :     if (own)
    2416           0 :       *own = *own | sobj->own;
    2417      366900 :     if (flags & SWIG_POINTER_DISOWN) {
    2418       86857 :       sobj->own = 0;
    2419             :     }
    2420             :     res = SWIG_OK;
    2421             :   } else {
    2422         427 :     if (implicit_conv) {
    2423           0 :       SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    2424           0 :       if (data && !data->implicitconv) {
    2425           0 :         PyObject *klass = data->klass;
    2426           0 :         if (klass) {
    2427             :           PyObject *impconv;
    2428           0 :           data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
    2429           0 :           impconv = SWIG_Python_CallFunctor(klass, obj);
    2430           0 :           data->implicitconv = 0;
    2431           0 :           if (PyErr_Occurred()) {
    2432           0 :             PyErr_Clear();
    2433             :             impconv = 0;
    2434             :           }
    2435           0 :           if (impconv) {
    2436           0 :             SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
    2437           0 :             if (iobj) {
    2438             :               void *vptr;
    2439           0 :               res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
    2440           0 :               if (SWIG_IsOK(res)) {
    2441           0 :                 if (ptr) {
    2442           0 :                   *ptr = vptr;
    2443             :                   /* transfer the ownership to 'ptr' */
    2444           0 :                   iobj->own = 0;
    2445             :                   res = SWIG_AddCast(res);
    2446           0 :                   res = SWIG_AddNewMask(res);
    2447             :                 } else {
    2448             :                   res = SWIG_AddCast(res);                  
    2449             :                 }
    2450             :               }
    2451             :             }
    2452           0 :             Py_DECREF(impconv);
    2453             :           }
    2454             :         }
    2455             :       }
    2456             :     }
    2457         427 :     if (!SWIG_IsOK(res) && obj == Py_None) {
    2458           0 :       if (ptr)
    2459           0 :         *ptr = 0;
    2460           0 :       if (PyErr_Occurred())
    2461           0 :         PyErr_Clear();
    2462             :       res = SWIG_OK;
    2463             :     }
    2464             :   }
    2465             :   return res;
    2466             : }
    2467             : 
    2468             : /* Convert a function ptr value */
    2469             : 
    2470             : SWIGRUNTIME int
    2471           1 : SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
    2472           1 :   if (!PyCFunction_Check(obj)) {
    2473           1 :     return SWIG_ConvertPtr(obj, ptr, ty, 0);
    2474             :   } else {
    2475           0 :     void *vptr = 0;
    2476             :     
    2477             :     /* here we get the method pointer for callbacks */
    2478           0 :     const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
    2479           0 :     const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    2480           0 :     if (desc)
    2481           0 :       desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
    2482           0 :     if (!desc) 
    2483           0 :       return SWIG_ERROR;
    2484           0 :     if (ty) {
    2485           0 :       swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
    2486           0 :       if (tc) {
    2487           0 :         int newmemory = 0;
    2488           0 :         *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
    2489             :         assert(!newmemory); /* newmemory handling not yet implemented */
    2490             :       } else {
    2491             :         return SWIG_ERROR;
    2492             :       }
    2493             :     } else {
    2494           0 :       *ptr = vptr;
    2495             :     }
    2496           0 :     return SWIG_OK;
    2497             :   }
    2498             : }
    2499             : 
    2500             : /* Convert a packed value value */
    2501             : 
    2502             : SWIGRUNTIME int
    2503             : SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
    2504             :   swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
    2505             :   if (!to) return SWIG_ERROR;
    2506             :   if (ty) {
    2507             :     if (to != ty) {
    2508             :       /* check type cast? */
    2509             :       swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
    2510             :       if (!tc) return SWIG_ERROR;
    2511             :     }
    2512             :   }
    2513             :   return SWIG_OK;
    2514             : }  
    2515             : 
    2516             : /* -----------------------------------------------------------------------------
    2517             :  * Create a new pointer object
    2518             :  * ----------------------------------------------------------------------------- */
    2519             : 
    2520             : /*
    2521             :   Create a new instance object, without calling __init__, and set the
    2522             :   'this' attribute.
    2523             : */
    2524             : 
    2525             : SWIGRUNTIME PyObject* 
    2526           0 : SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
    2527             : {
    2528             : #if (PY_VERSION_HEX >= 0x02020000)
    2529             :   PyObject *inst = 0;
    2530           0 :   PyObject *newraw = data->newraw;
    2531           0 :   if (newraw) {
    2532           0 :     inst = PyObject_Call(newraw, data->newargs, NULL);
    2533           0 :     if (inst) {
    2534             : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
    2535           0 :       PyObject **dictptr = _PyObject_GetDictPtr(inst);
    2536           0 :       if (dictptr != NULL) {
    2537           0 :         PyObject *dict = *dictptr;
    2538           0 :         if (dict == NULL) {
    2539           0 :           dict = PyDict_New();
    2540           0 :           *dictptr = dict;
    2541           0 :           PyDict_SetItem(dict, SWIG_This(), swig_this);
    2542             :         }
    2543             :       }
    2544             : #else
    2545             :       PyObject *key = SWIG_This();
    2546             :       PyObject_SetAttr(inst, key, swig_this);
    2547             : #endif
    2548             :     }
    2549             :   } else {
    2550             : #if PY_VERSION_HEX >= 0x03000000
    2551             :     inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
    2552             :     if (inst) {
    2553             :       PyObject_SetAttr(inst, SWIG_This(), swig_this);
    2554             :       Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
    2555             :     }
    2556             : #else
    2557           0 :     PyObject *dict = PyDict_New();
    2558           0 :     if (dict) {
    2559           0 :       PyDict_SetItem(dict, SWIG_This(), swig_this);
    2560           0 :       inst = PyInstance_NewRaw(data->newargs, dict);
    2561           0 :       Py_DECREF(dict);
    2562             :     }
    2563             : #endif
    2564             :   }
    2565           0 :   return inst;
    2566             : #else
    2567             : #if (PY_VERSION_HEX >= 0x02010000)
    2568             :   PyObject *inst = 0;
    2569             :   PyObject *dict = PyDict_New();
    2570             :   if (dict) {
    2571             :     PyDict_SetItem(dict, SWIG_This(), swig_this);
    2572             :     inst = PyInstance_NewRaw(data->newargs, dict);
    2573             :     Py_DECREF(dict);
    2574             :   }
    2575             :   return (PyObject *) inst;
    2576             : #else
    2577             :   PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
    2578             :   if (inst == NULL) {
    2579             :     return NULL;
    2580             :   }
    2581             :   inst->in_class = (PyClassObject *)data->newargs;
    2582             :   Py_INCREF(inst->in_class);
    2583             :   inst->in_dict = PyDict_New();
    2584             :   if (inst->in_dict == NULL) {
    2585             :     Py_DECREF(inst);
    2586             :     return NULL;
    2587             :   }
    2588             : #ifdef Py_TPFLAGS_HAVE_WEAKREFS
    2589             :   inst->in_weakreflist = NULL;
    2590             : #endif
    2591             : #ifdef Py_TPFLAGS_GC
    2592             :   PyObject_GC_Init(inst);
    2593             : #endif
    2594             :   PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
    2595             :   return (PyObject *) inst;
    2596             : #endif
    2597             : #endif
    2598             : }
    2599             : 
    2600             : SWIGRUNTIME void
    2601             : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
    2602             : {
    2603             :  PyObject *dict;
    2604             : #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
    2605             :  PyObject **dictptr = _PyObject_GetDictPtr(inst);
    2606             :  if (dictptr != NULL) {
    2607             :    dict = *dictptr;
    2608             :    if (dict == NULL) {
    2609             :      dict = PyDict_New();
    2610             :      *dictptr = dict;
    2611             :    }
    2612             :    PyDict_SetItem(dict, SWIG_This(), swig_this);
    2613             :    return;
    2614             :  }
    2615             : #endif
    2616             :  dict = PyObject_GetAttrString(inst, (char*)"__dict__");
    2617             :  PyDict_SetItem(dict, SWIG_This(), swig_this);
    2618             :  Py_DECREF(dict);
    2619             : } 
    2620             : 
    2621             : 
    2622             : SWIGINTERN PyObject *
    2623             : SWIG_Python_InitShadowInstance(PyObject *args) {
    2624             :   PyObject *obj[2];
    2625             :   if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    2626             :     return NULL;
    2627             :   } else {
    2628             :     SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    2629             :     if (sthis) {
    2630             :       SwigPyObject_append((PyObject*) sthis, obj[1]);
    2631             :     } else {
    2632             :       SWIG_Python_SetSwigThis(obj[0], obj[1]);
    2633             :     }
    2634             :     return SWIG_Py_Void();
    2635             :   }
    2636             : }
    2637             : 
    2638             : /* Create a new pointer object */
    2639             : 
    2640             : SWIGRUNTIME PyObject *
    2641       90518 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
    2642             :   SwigPyClientData *clientdata;
    2643             :   PyObject * robj;
    2644             :   int own;
    2645             : 
    2646       90518 :   if (!ptr)
    2647           1 :     return SWIG_Py_Void();
    2648             : 
    2649       90517 :   clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
    2650           0 :   own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
    2651       90517 :   if (clientdata && clientdata->pytype) {
    2652             :     SwigPyObject *newobj;
    2653           0 :     if (flags & SWIG_BUILTIN_TP_INIT) {
    2654             :       newobj = (SwigPyObject*) self;
    2655           0 :       if (newobj->ptr) {
    2656           0 :         PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
    2657           0 :         while (newobj->next)
    2658             :           newobj = (SwigPyObject *) newobj->next;
    2659           0 :         newobj->next = next_self;
    2660             :         newobj = (SwigPyObject *)next_self;
    2661             : #ifdef SWIGPYTHON_BUILTIN
    2662             :         newobj->dict = 0;
    2663             : #endif
    2664             :       }
    2665             :     } else {
    2666           0 :       newobj = PyObject_New(SwigPyObject, clientdata->pytype);
    2667             : #ifdef SWIGPYTHON_BUILTIN
    2668             :       newobj->dict = 0;
    2669             : #endif
    2670             :     }
    2671           0 :     if (newobj) {
    2672           0 :       newobj->ptr = ptr;
    2673           0 :       newobj->ty = type;
    2674           0 :       newobj->own = own;
    2675           0 :       newobj->next = 0;
    2676           0 :       return (PyObject*) newobj;
    2677             :     }
    2678           0 :     return SWIG_Py_Void();
    2679             :   }
    2680             : 
    2681             :   assert(!(flags & SWIG_BUILTIN_TP_INIT));
    2682             : 
    2683       90517 :   robj = SwigPyObject_New(ptr, type, own);
    2684       90517 :   if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    2685       82095 :     PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    2686       82095 :     Py_DECREF(robj);
    2687             :     robj = inst;
    2688             :   }
    2689             :   return robj;
    2690             : }
    2691             : 
    2692             : /* Create a new packed object */
    2693             : 
    2694             : SWIGRUNTIMEINLINE PyObject *
    2695             : SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
    2696           0 :   return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
    2697             : }
    2698             : 
    2699             : /* -----------------------------------------------------------------------------*
    2700             :  *  Get type list 
    2701             :  * -----------------------------------------------------------------------------*/
    2702             : 
    2703             : #ifdef SWIG_LINK_RUNTIME
    2704             : void *SWIG_ReturnGlobalTypeList(void *);
    2705             : #endif
    2706             : 
    2707             : SWIGRUNTIME swig_module_info *
    2708           0 : SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
    2709             :   static void *type_pointer = (void *)0;
    2710             :   /* first check if module already created */
    2711           0 :   if (!type_pointer) {
    2712             : #ifdef SWIG_LINK_RUNTIME
    2713             :     type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
    2714             : #else
    2715             : # ifdef SWIGPY_USE_CAPSULE
    2716           0 :     type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
    2717             : # else
    2718             :     type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
    2719             :                                     (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
    2720             : # endif
    2721           0 :     if (PyErr_Occurred()) {
    2722           0 :       PyErr_Clear();
    2723           0 :       type_pointer = (void *)0;
    2724             :     }
    2725             : #endif
    2726             :   }
    2727           0 :   return (swig_module_info *) type_pointer;
    2728             : }
    2729             : 
    2730             : #if PY_MAJOR_VERSION < 2
    2731             : /* PyModule_AddObject function was introduced in Python 2.0.  The following function
    2732             :    is copied out of Python/modsupport.c in python version 2.3.4 */
    2733             : SWIGINTERN int
    2734             : PyModule_AddObject(PyObject *m, char *name, PyObject *o)
    2735             : {
    2736             :   PyObject *dict;
    2737             :   if (!PyModule_Check(m)) {
    2738             :     PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
    2739             :     return SWIG_ERROR;
    2740             :   }
    2741             :   if (!o) {
    2742             :     PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
    2743             :     return SWIG_ERROR;
    2744             :   }
    2745             :   
    2746             :   dict = PyModule_GetDict(m);
    2747             :   if (dict == NULL) {
    2748             :     /* Internal error -- modules must have a dict! */
    2749             :     PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
    2750             :                  PyModule_GetName(m));
    2751             :     return SWIG_ERROR;
    2752             :   }
    2753             :   if (PyDict_SetItemString(dict, name, o))
    2754             :     return SWIG_ERROR;
    2755             :   Py_DECREF(o);
    2756             :   return SWIG_OK;
    2757             : }
    2758             : #endif
    2759             : 
    2760             : SWIGRUNTIME void
    2761             : #ifdef SWIGPY_USE_CAPSULE
    2762         652 : SWIG_Python_DestroyModule(PyObject *obj)
    2763             : #else
    2764             : SWIG_Python_DestroyModule(void *vptr)
    2765             : #endif
    2766             : {
    2767             : #ifdef SWIGPY_USE_CAPSULE
    2768         652 :   swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
    2769             : #else
    2770             :   swig_module_info *swig_module = (swig_module_info *) vptr;
    2771             : #endif
    2772         652 :   swig_type_info **types = swig_module->types;
    2773             :   size_t i;
    2774      166260 :   for (i =0; i < swig_module->size; ++i) {
    2775      165608 :     swig_type_info *ty = types[i];
    2776      165608 :     if (ty->owndata) {
    2777       48900 :       SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
    2778       48900 :       if (data) SwigPyClientData_Del(data);
    2779             :     }
    2780             :   }
    2781         652 :   Py_DECREF(SWIG_This());
    2782         652 :   swig_this = NULL;
    2783         652 : }
    2784             : 
    2785             : SWIGRUNTIME void
    2786         652 : SWIG_Python_SetModule(swig_module_info *swig_module) {
    2787             : #if PY_VERSION_HEX >= 0x03000000
    2788             :  /* Add a dummy module object into sys.modules */
    2789             :   PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
    2790             : #else
    2791             :   static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
    2792         652 :   PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
    2793             : #endif
    2794             : #ifdef SWIGPY_USE_CAPSULE
    2795         652 :   PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
    2796         652 :   if (pointer && module) {
    2797         652 :     PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
    2798             :   } else {
    2799           0 :     Py_XDECREF(pointer);
    2800             :   }
    2801             : #else
    2802             :   PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
    2803             :   if (pointer && module) {
    2804             :     PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
    2805             :   } else {
    2806             :     Py_XDECREF(pointer);
    2807             :   }
    2808             : #endif
    2809         652 : }
    2810             : 
    2811             : /* The python cached type query */
    2812             : SWIGRUNTIME PyObject *
    2813             : SWIG_Python_TypeCache(void) {
    2814             :   static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
    2815             :   return cache;
    2816             : }
    2817             : 
    2818             : SWIGRUNTIME swig_type_info *
    2819             : SWIG_Python_TypeQuery(const char *type)
    2820             : {
    2821             :   PyObject *cache = SWIG_Python_TypeCache();
    2822             :   PyObject *key = SWIG_Python_str_FromChar(type); 
    2823             :   PyObject *obj = PyDict_GetItem(cache, key);
    2824             :   swig_type_info *descriptor;
    2825             :   if (obj) {
    2826             : #ifdef SWIGPY_USE_CAPSULE
    2827             :     descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
    2828             : #else
    2829             :     descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
    2830             : #endif
    2831             :   } else {
    2832             :     swig_module_info *swig_module = SWIG_GetModule(0);
    2833             :     descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    2834             :     if (descriptor) {
    2835             : #ifdef SWIGPY_USE_CAPSULE
    2836             :       obj = PyCapsule_New((void*) descriptor, NULL, NULL);
    2837             : #else
    2838             :       obj = PyCObject_FromVoidPtr(descriptor, NULL);
    2839             : #endif
    2840             :       PyDict_SetItem(cache, key, obj);
    2841             :       Py_DECREF(obj);
    2842             :     }
    2843             :   }
    2844             :   Py_DECREF(key);
    2845             :   return descriptor;
    2846             : }
    2847             : 
    2848             : /* 
    2849             :    For backward compatibility only
    2850             : */
    2851             : #define SWIG_POINTER_EXCEPTION  0
    2852             : #define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
    2853             : #define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)
    2854             : 
    2855             : SWIGRUNTIME int
    2856             : SWIG_Python_AddErrMesg(const char* mesg, int infront)
    2857             : {  
    2858             :   if (PyErr_Occurred()) {
    2859             :     PyObject *type = 0;
    2860             :     PyObject *value = 0;
    2861             :     PyObject *traceback = 0;
    2862             :     PyErr_Fetch(&type, &value, &traceback);
    2863             :     if (value) {
    2864             :       char *tmp;
    2865             :       PyObject *old_str = PyObject_Str(value);
    2866             :       Py_XINCREF(type);
    2867             :       PyErr_Clear();
    2868             :       if (infront) {
    2869             :         PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
    2870             :       } else {
    2871             :         PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
    2872             :       }
    2873             :       SWIG_Python_str_DelForPy3(tmp);
    2874             :       Py_DECREF(old_str);
    2875             :     }
    2876             :     return 1;
    2877             :   } else {
    2878             :     return 0;
    2879             :   }
    2880             : }
    2881             :   
    2882             : SWIGRUNTIME int
    2883             : SWIG_Python_ArgFail(int argnum)
    2884             : {
    2885             :   if (PyErr_Occurred()) {
    2886             :     /* add information about failing argument */
    2887             :     char mesg[256];
    2888             :     PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    2889             :     return SWIG_Python_AddErrMesg(mesg, 1);
    2890             :   } else {
    2891             :     return 0;
    2892             :   }
    2893             : }
    2894             : 
    2895             : SWIGRUNTIMEINLINE const char *
    2896             : SwigPyObject_GetDesc(PyObject *self)
    2897             : {
    2898             :   SwigPyObject *v = (SwigPyObject *)self;
    2899             :   swig_type_info *ty = v ? v->ty : 0;
    2900             :   return ty ? ty->str : "";
    2901             : }
    2902             : 
    2903             : SWIGRUNTIME void
    2904             : SWIG_Python_TypeError(const char *type, PyObject *obj)
    2905             : {
    2906             :   if (type) {
    2907             : #if defined(SWIG_COBJECT_TYPES)
    2908             :     if (obj && SwigPyObject_Check(obj)) {
    2909             :       const char *otype = (const char *) SwigPyObject_GetDesc(obj);
    2910             :       if (otype) {
    2911             :         PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
    2912             :                      type, otype);
    2913             :         return;
    2914             :       }
    2915             :     } else 
    2916             : #endif      
    2917             :     {
    2918             :       const char *otype = (obj ? obj->ob_type->tp_name : 0); 
    2919             :       if (otype) {
    2920             :         PyObject *str = PyObject_Str(obj);
    2921             :         const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
    2922             :         if (cstr) {
    2923             :           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
    2924             :                        type, otype, cstr);
    2925             :           SWIG_Python_str_DelForPy3(cstr);
    2926             :         } else {
    2927             :           PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
    2928             :                        type, otype);
    2929             :         }
    2930             :         Py_XDECREF(str);
    2931             :         return;
    2932             :       }
    2933             :     }   
    2934             :     PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
    2935             :   } else {
    2936             :     PyErr_Format(PyExc_TypeError, "unexpected type is received");
    2937             :   }
    2938             : }
    2939             : 
    2940             : 
    2941             : /* Convert a pointer value, signal an exception on a type mismatch */
    2942             : SWIGRUNTIME void *
    2943             : SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
    2944             :   void *result;
    2945             :   if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    2946             :     PyErr_Clear();
    2947             : #if SWIG_POINTER_EXCEPTION
    2948             :     if (flags) {
    2949             :       SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
    2950             :       SWIG_Python_ArgFail(argnum);
    2951             :     }
    2952             : #endif
    2953             :   }
    2954             :   return result;
    2955             : }
    2956             : 
    2957             : #ifdef SWIGPYTHON_BUILTIN
    2958             : SWIGRUNTIME int
    2959             : SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
    2960             :   PyTypeObject *tp = obj->ob_type;
    2961             :   PyObject *descr;
    2962             :   PyObject *encoded_name;
    2963             :   descrsetfunc f;
    2964             :   int res = -1;
    2965             : 
    2966             : # ifdef Py_USING_UNICODE
    2967             :   if (PyString_Check(name)) {
    2968             :     name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    2969             :     if (!name)
    2970             :       return -1;
    2971             :   } else if (!PyUnicode_Check(name))
    2972             : # else
    2973             :   if (!PyString_Check(name))
    2974             : # endif
    2975             :   {
    2976             :     PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    2977             :     return -1;
    2978             :   } else {
    2979             :     Py_INCREF(name);
    2980             :   }
    2981             : 
    2982             :   if (!tp->tp_dict) {
    2983             :     if (PyType_Ready(tp) < 0)
    2984             :       goto done;
    2985             :   }
    2986             : 
    2987             :   descr = _PyType_Lookup(tp, name);
    2988             :   f = NULL;
    2989             :   if (descr != NULL)
    2990             :     f = descr->ob_type->tp_descr_set;
    2991             :   if (!f) {
    2992             :     if (PyString_Check(name)) {
    2993             :       encoded_name = name;
    2994             :       Py_INCREF(name);
    2995             :     } else {
    2996             :       encoded_name = PyUnicode_AsUTF8String(name);
    2997             :     }
    2998             :     PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    2999             :     Py_DECREF(encoded_name);
    3000             :   } else {
    3001             :     res = f(descr, obj, value);
    3002             :   }
    3003             :   
    3004             :   done:
    3005             :   Py_DECREF(name);
    3006             :   return res;
    3007             : }
    3008             : #endif
    3009             : 
    3010             : 
    3011             : #ifdef __cplusplus
    3012             : }
    3013             : #endif
    3014             : 
    3015             : 
    3016             : 
    3017             : #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
    3018             : 
    3019             : #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
    3020             : 
    3021             : 
    3022             : 
    3023             : // Forward declaration to be inserted at the start of LLDBWrapPython.h
    3024             : #include "lldb/API/SBDebugger.h"
    3025             : #include "lldb/API/SBValue.h"
    3026             : 
    3027             : SWIGEXPORT lldb::ValueObjectSP
    3028           0 : LLDBSWIGPython_GetValueObjectSPFromSBValue (void* data)
    3029             : {
    3030             :     lldb::ValueObjectSP valobj_sp;
    3031           0 :     if (data)
    3032             :     {
    3033             :         lldb::SBValue* sb_ptr = (lldb::SBValue *)data;
    3034           0 :         valobj_sp = sb_ptr->GetSP();
    3035             :     }
    3036           0 :     return valobj_sp;
    3037             : }
    3038             : 
    3039             : #ifdef __cplusplus
    3040             : extern "C" {
    3041             : #endif
    3042             : 
    3043             : void LLDBSwigPythonCallPythonLogOutputCallback(const char *str, void *baton);
    3044             : 
    3045             : #ifdef __cplusplus
    3046             : }
    3047             : #endif
    3048             : 
    3049             : 
    3050             : /* -------- TYPES TABLE (BEGIN) -------- */
    3051             : 
    3052             : #define SWIGTYPE_p_FILE swig_types[0]
    3053             : #define SWIGTYPE_p_bool swig_types[1]
    3054             : #define SWIGTYPE_p_char swig_types[2]
    3055             : #define SWIGTYPE_p_double swig_types[3]
    3056             : #define SWIGTYPE_p_f_p_void__p_void swig_types[4]
    3057             : #define SWIGTYPE_p_f_p_void_p_q_const__void_size_t__void swig_types[5]
    3058             : #define SWIGTYPE_p_int swig_types[6]
    3059             : #define SWIGTYPE_p_lldb__ConnectionStatus swig_types[7]
    3060             : #define SWIGTYPE_p_lldb__SBAddress swig_types[8]
    3061             : #define SWIGTYPE_p_lldb__SBAttachInfo swig_types[9]
    3062             : #define SWIGTYPE_p_lldb__SBBlock swig_types[10]
    3063             : #define SWIGTYPE_p_lldb__SBBreakpoint swig_types[11]
    3064             : #define SWIGTYPE_p_lldb__SBBreakpointList swig_types[12]
    3065             : #define SWIGTYPE_p_lldb__SBBreakpointLocation swig_types[13]
    3066             : #define SWIGTYPE_p_lldb__SBBreakpointName swig_types[14]
    3067             : #define SWIGTYPE_p_lldb__SBBroadcaster swig_types[15]
    3068             : #define SWIGTYPE_p_lldb__SBCommandInterpreter swig_types[16]
    3069             : #define SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions swig_types[17]
    3070             : #define SWIGTYPE_p_lldb__SBCommandReturnObject swig_types[18]
    3071             : #define SWIGTYPE_p_lldb__SBCommunication swig_types[19]
    3072             : #define SWIGTYPE_p_lldb__SBCompileUnit swig_types[20]
    3073             : #define SWIGTYPE_p_lldb__SBData swig_types[21]
    3074             : #define SWIGTYPE_p_lldb__SBDebugger swig_types[22]
    3075             : #define SWIGTYPE_p_lldb__SBDeclaration swig_types[23]
    3076             : #define SWIGTYPE_p_lldb__SBError swig_types[24]
    3077             : #define SWIGTYPE_p_lldb__SBEvent swig_types[25]
    3078             : #define SWIGTYPE_p_lldb__SBExecutionContext swig_types[26]
    3079             : #define SWIGTYPE_p_lldb__SBExpressionOptions swig_types[27]
    3080             : #define SWIGTYPE_p_lldb__SBFileSpec swig_types[28]
    3081             : #define SWIGTYPE_p_lldb__SBFileSpecList swig_types[29]
    3082             : #define SWIGTYPE_p_lldb__SBFrame swig_types[30]
    3083             : #define SWIGTYPE_p_lldb__SBFunction swig_types[31]
    3084             : #define SWIGTYPE_p_lldb__SBHostOS swig_types[32]
    3085             : #define SWIGTYPE_p_lldb__SBInstruction swig_types[33]
    3086             : #define SWIGTYPE_p_lldb__SBInstructionList swig_types[34]
    3087             : #define SWIGTYPE_p_lldb__SBLanguageRuntime swig_types[35]
    3088             : #define SWIGTYPE_p_lldb__SBLaunchInfo swig_types[36]
    3089             : #define SWIGTYPE_p_lldb__SBLineEntry swig_types[37]
    3090             : #define SWIGTYPE_p_lldb__SBListener swig_types[38]
    3091             : #define SWIGTYPE_p_lldb__SBMemoryRegionInfo swig_types[39]
    3092             : #define SWIGTYPE_p_lldb__SBMemoryRegionInfoList swig_types[40]
    3093             : #define SWIGTYPE_p_lldb__SBModule swig_types[41]
    3094             : #define SWIGTYPE_p_lldb__SBModuleSpec swig_types[42]
    3095             : #define SWIGTYPE_p_lldb__SBModuleSpecList swig_types[43]
    3096             : #define SWIGTYPE_p_lldb__SBPlatform swig_types[44]
    3097             : #define SWIGTYPE_p_lldb__SBPlatformConnectOptions swig_types[45]
    3098             : #define SWIGTYPE_p_lldb__SBPlatformShellCommand swig_types[46]
    3099             : #define SWIGTYPE_p_lldb__SBProcess swig_types[47]
    3100             : #define SWIGTYPE_p_lldb__SBProcessInfo swig_types[48]
    3101             : #define SWIGTYPE_p_lldb__SBQueue swig_types[49]
    3102             : #define SWIGTYPE_p_lldb__SBQueueItem swig_types[50]
    3103             : #define SWIGTYPE_p_lldb__SBSection swig_types[51]
    3104             : #define SWIGTYPE_p_lldb__SBSourceManager swig_types[52]
    3105             : #define SWIGTYPE_p_lldb__SBStream swig_types[53]
    3106             : #define SWIGTYPE_p_lldb__SBStringList swig_types[54]
    3107             : #define SWIGTYPE_p_lldb__SBStructuredData swig_types[55]
    3108             : #define SWIGTYPE_p_lldb__SBSymbol swig_types[56]
    3109             : #define SWIGTYPE_p_lldb__SBSymbolContext swig_types[57]
    3110             : #define SWIGTYPE_p_lldb__SBSymbolContextList swig_types[58]
    3111             : #define SWIGTYPE_p_lldb__SBTarget swig_types[59]
    3112             : #define SWIGTYPE_p_lldb__SBThread swig_types[60]
    3113             : #define SWIGTYPE_p_lldb__SBThreadCollection swig_types[61]
    3114             : #define SWIGTYPE_p_lldb__SBThreadPlan swig_types[62]
    3115             : #define SWIGTYPE_p_lldb__SBTrace swig_types[63]
    3116             : #define SWIGTYPE_p_lldb__SBTraceOptions swig_types[64]
    3117             : #define SWIGTYPE_p_lldb__SBType swig_types[65]
    3118             : #define SWIGTYPE_p_lldb__SBTypeCategory swig_types[66]
    3119             : #define SWIGTYPE_p_lldb__SBTypeEnumMember swig_types[67]
    3120             : #define SWIGTYPE_p_lldb__SBTypeEnumMemberList swig_types[68]
    3121             : #define SWIGTYPE_p_lldb__SBTypeFilter swig_types[69]
    3122             : #define SWIGTYPE_p_lldb__SBTypeFormat swig_types[70]
    3123             : #define SWIGTYPE_p_lldb__SBTypeList swig_types[71]
    3124             : #define SWIGTYPE_p_lldb__SBTypeMember swig_types[72]
    3125             : #define SWIGTYPE_p_lldb__SBTypeMemberFunction swig_types[73]
    3126             : #define SWIGTYPE_p_lldb__SBTypeNameSpecifier swig_types[74]
    3127             : #define SWIGTYPE_p_lldb__SBTypeSummary swig_types[75]
    3128             : #define SWIGTYPE_p_lldb__SBTypeSummaryOptions swig_types[76]
    3129             : #define SWIGTYPE_p_lldb__SBTypeSynthetic swig_types[77]
    3130             : #define SWIGTYPE_p_lldb__SBUnixSignals swig_types[78]
    3131             : #define SWIGTYPE_p_lldb__SBValue swig_types[79]
    3132             : #define SWIGTYPE_p_lldb__SBValueList swig_types[80]
    3133             : #define SWIGTYPE_p_lldb__SBVariablesOptions swig_types[81]
    3134             : #define SWIGTYPE_p_lldb__SBWatchpoint swig_types[82]
    3135             : #define SWIGTYPE_p_lldb_private__SharingPtrT_lldb_private__ValueObject_t swig_types[83]
    3136             : #define SWIGTYPE_p_long_double swig_types[84]
    3137             : #define SWIGTYPE_p_long_long swig_types[85]
    3138             : #define SWIGTYPE_p_p_void swig_types[86]
    3139             : #define SWIGTYPE_p_pthread_rwlock_t swig_types[87]
    3140             : #define SWIGTYPE_p_pthread_t swig_types[88]
    3141             : #define SWIGTYPE_p_short swig_types[89]
    3142             : #define SWIGTYPE_p_signed_char swig_types[90]
    3143             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ABI_t swig_types[91]
    3144             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Baton_t swig_types[92]
    3145             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Block_t swig_types[93]
    3146             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointLocation_t swig_types[94]
    3147             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointResolver_t swig_types[95]
    3148             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__BreakpointSite_t swig_types[96]
    3149             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Breakpoint_t swig_types[97]
    3150             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__BroadcasterManager_t swig_types[98]
    3151             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Broadcaster_t swig_types[99]
    3152             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ClangASTImporter_t swig_types[100]
    3153             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__CommandObject_t swig_types[101]
    3154             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Communication_t swig_types[102]
    3155             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__CompileUnit_t swig_types[103]
    3156             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Connection_t swig_types[104]
    3157             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataBuffer_t swig_types[105]
    3158             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__DataExtractor_t swig_types[106]
    3159             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Debugger_t swig_types[107]
    3160             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Disassembler_t swig_types[108]
    3161             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__DynamicLoader_t swig_types[109]
    3162             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventDataStructuredData_t swig_types[110]
    3163             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__EventData_t swig_types[111]
    3164             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Event_t swig_types[112]
    3165             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExecutionContextRef_t swig_types[113]
    3166             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ExpressionVariable_t swig_types[114]
    3167             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__File_t swig_types[115]
    3168             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__FuncUnwinders_t swig_types[116]
    3169             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__FunctionCaller_t swig_types[117]
    3170             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Function_t swig_types[118]
    3171             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOHandler_t swig_types[119]
    3172             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__IOObject_t swig_types[120]
    3173             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__IRExecutionUnit_t swig_types[121]
    3174             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__InlineFunctionInfo_t swig_types[122]
    3175             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Instruction_t swig_types[123]
    3176             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__InstrumentationRuntime_t swig_types[124]
    3177             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__JITLoader_t swig_types[125]
    3178             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__LanguageRuntime_t swig_types[126]
    3179             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__LineTable_t swig_types[127]
    3180             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Listener_t swig_types[128]
    3181             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryHistory_t swig_types[129]
    3182             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t swig_types[130]
    3183             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Module_t swig_types[131]
    3184             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[132]
    3185             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFile_t swig_types[133]
    3186             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueArch_t swig_types[134]
    3187             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueArgs_t swig_types[135]
    3188             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueArray_t swig_types[136]
    3189             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueBoolean_t swig_types[137]
    3190             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueDictionary_t swig_types[138]
    3191             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueFileSpecList_t swig_types[139]
    3192             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueFileSpec_t swig_types[140]
    3193             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueFormat_t swig_types[141]
    3194             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValuePathMappings_t swig_types[142]
    3195             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueProperties_t swig_types[143]
    3196             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueRegex_t swig_types[144]
    3197             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueSInt64_t swig_types[145]
    3198             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueString_t swig_types[146]
    3199             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueUInt64_t swig_types[147]
    3200             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueUUID_t swig_types[148]
    3201             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValue_t swig_types[149]
    3202             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Platform_t swig_types[150]
    3203             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t swig_types[151]
    3204             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t swig_types[152]
    3205             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Process_t swig_types[153]
    3206             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Property_t swig_types[154]
    3207             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t swig_types[155]
    3208             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Queue_t swig_types[156]
    3209             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__REPL_t swig_types[157]
    3210             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t swig_types[158]
    3211             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterContext_t swig_types[159]
    3212             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegularExpression_t swig_types[160]
    3213             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptInterpreter_t swig_types[161]
    3214             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t swig_types[162]
    3215             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t swig_types[163]
    3216             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SearchFilter_t swig_types[164]
    3217             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SectionLoadList_t swig_types[165]
    3218             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Section_t swig_types[166]
    3219             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Settings_t swig_types[167]
    3220             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameList_t swig_types[168]
    3221             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrame_t swig_types[169]
    3222             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StopInfo_t swig_types[170]
    3223             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StoppointLocation_t swig_types[171]
    3224             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StreamFile_t swig_types[172]
    3225             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Stream_t swig_types[173]
    3226             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StringSummaryFormat_t swig_types[174]
    3227             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t swig_types[175]
    3228             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t swig_types[176]
    3229             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolFileType_t swig_types[177]
    3230             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolFile_t swig_types[178]
    3231             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t swig_types[179]
    3232             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildren_t swig_types[180]
    3233             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__SystemRuntime_t swig_types[181]
    3234             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TargetProperties_t swig_types[182]
    3235             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Target_t swig_types[183]
    3236             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadCollection_t swig_types[184]
    3237             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t swig_types[185]
    3238             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlan_t swig_types[186]
    3239             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Thread_t swig_types[187]
    3240             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TraceOptions_t swig_types[188]
    3241             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t swig_types[189]
    3242             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t swig_types[190]
    3243             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFilterImpl_t swig_types[191]
    3244             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFormatImpl_t swig_types[192]
    3245             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeImpl_t swig_types[193]
    3246             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t swig_types[194]
    3247             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t swig_types[195]
    3248             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t swig_types[196]
    3249             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t swig_types[197]
    3250             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSystem_t swig_types[198]
    3251             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeValidatorImpl_t swig_types[199]
    3252             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Type_t swig_types[200]
    3253             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnixSignals_t swig_types[201]
    3254             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindAssembly_t swig_types[202]
    3255             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindPlan_t swig_types[203]
    3256             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__UserExpression_t swig_types[204]
    3257             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__UtilityFunction_t swig_types[205]
    3258             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueList_t swig_types[206]
    3259             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObjectList_t swig_types[207]
    3260             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Value_t swig_types[208]
    3261             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__VariableList_t swig_types[209]
    3262             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Variable_t swig_types[210]
    3263             : #define SWIGTYPE_p_std__shared_ptrT_lldb_private__Watchpoint_t swig_types[211]
    3264             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__ClangASTContext_t swig_types[212]
    3265             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__ClangModulesDeclVendor_t swig_types[213]
    3266             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__ClangPersistentVariables_t swig_types[214]
    3267             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t swig_types[215]
    3268             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicLoader_t swig_types[216]
    3269             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__GoASTContext_t swig_types[217]
    3270             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__JITLoaderList_t swig_types[218]
    3271             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t swig_types[219]
    3272             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__OperatingSystem_t swig_types[220]
    3273             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__ScriptInterpreter_t swig_types[221]
    3274             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__SectionList_t swig_types[222]
    3275             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__SourceManager_t swig_types[223]
    3276             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__StackFrame_t swig_types[224]
    3277             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__StructuredDataImpl_t swig_types[225]
    3278             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__SymbolVendor_t swig_types[226]
    3279             : #define SWIGTYPE_p_std__unique_ptrT_lldb_private__SystemRuntime_t swig_types[227]
    3280             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__BreakpointLocation_t swig_types[228]
    3281             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__BreakpointSite_t swig_types[229]
    3282             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Breakpoint_t swig_types[230]
    3283             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__BroadcasterManager_t swig_types[231]
    3284             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Debugger_t swig_types[232]
    3285             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Listener_t swig_types[233]
    3286             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Module_t swig_types[234]
    3287             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[235]
    3288             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__ObjectFile_t swig_types[236]
    3289             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__OptionValue_t swig_types[237]
    3290             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Process_t swig_types[238]
    3291             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Queue_t swig_types[239]
    3292             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Section_t swig_types[240]
    3293             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__StackFrame_t swig_types[241]
    3294             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Stream_t swig_types[242]
    3295             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t swig_types[243]
    3296             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__SymbolFileType_t swig_types[244]
    3297             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Target_t swig_types[245]
    3298             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Thread_t swig_types[246]
    3299             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__Type_t swig_types[247]
    3300             : #define SWIGTYPE_p_std__weak_ptrT_lldb_private__UnixSignals_t swig_types[248]
    3301             : #define SWIGTYPE_p_unsigned_char swig_types[249]
    3302             : #define SWIGTYPE_p_unsigned_int swig_types[250]
    3303             : #define SWIGTYPE_p_unsigned_long_long swig_types[251]
    3304             : #define SWIGTYPE_p_unsigned_short swig_types[252]
    3305             : #define SWIGTYPE_p_void swig_types[253]
    3306             : static swig_type_info *swig_types[255];
    3307             : static swig_module_info swig_module = {swig_types, 254, 0, 0, 0, 0};
    3308             : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
    3309             : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
    3310             : 
    3311             : /* -------- TYPES TABLE (END) -------- */
    3312             : 
    3313             : #if (PY_VERSION_HEX <= 0x02000000)
    3314             : # if !defined(SWIG_PYTHON_CLASSIC)
    3315             : #  error "This python version requires swig to be run with the '-classic' option"
    3316             : # endif
    3317             : #endif
    3318             : 
    3319             : /*-----------------------------------------------
    3320             :               @(target):= _lldb.so
    3321             :   ------------------------------------------------*/
    3322             : #if PY_VERSION_HEX >= 0x03000000
    3323             : #  define SWIG_init    PyInit__lldb
    3324             : 
    3325             : #else
    3326             : #  define SWIG_init    init_lldb
    3327             : 
    3328             : #endif
    3329             : #define SWIG_name    "_lldb"
    3330             : 
    3331             : #define SWIGVERSION 0x030012 
    3332             : #define SWIG_VERSION SWIGVERSION
    3333             : 
    3334             : 
    3335             : #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
    3336             : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
    3337             : 
    3338             : 
    3339             : #include <stdexcept>
    3340             : 
    3341             : 
    3342             : namespace swig {
    3343             :   class SwigPtr_PyObject {
    3344             :   protected:
    3345             :     PyObject *_obj;
    3346             : 
    3347             :   public:
    3348             :     SwigPtr_PyObject() :_obj(0)
    3349             :     {
    3350             :     }
    3351             : 
    3352             :     SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    3353             :     {
    3354             :       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3355             :       Py_XINCREF(_obj);      
    3356             :       SWIG_PYTHON_THREAD_END_BLOCK;
    3357             :     }
    3358             :     
    3359             :     SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    3360             :     {
    3361             :       if (initial_ref) {
    3362             :         SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3363             :         Py_XINCREF(_obj);
    3364             :         SWIG_PYTHON_THREAD_END_BLOCK;
    3365             :       }
    3366             :     }
    3367             :     
    3368             :     SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    3369             :     {
    3370             :       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3371             :       Py_XINCREF(item._obj);
    3372             :       Py_XDECREF(_obj);
    3373             :       _obj = item._obj;
    3374             :       SWIG_PYTHON_THREAD_END_BLOCK;
    3375             :       return *this;      
    3376             :     }
    3377             :     
    3378             :     ~SwigPtr_PyObject() 
    3379             :     {
    3380             :       SWIG_PYTHON_THREAD_BEGIN_BLOCK;
    3381             :       Py_XDECREF(_obj);
    3382             :       SWIG_PYTHON_THREAD_END_BLOCK;
    3383             :     }
    3384             :     
    3385             :     operator PyObject *() const
    3386             :     {
    3387             :       return _obj;
    3388             :     }
    3389             : 
    3390             :     PyObject *operator->() const
    3391             :     {
    3392             :       return _obj;
    3393             :     }
    3394             :   };
    3395             : }
    3396             : 
    3397             : 
    3398             : namespace swig {
    3399             :   struct SwigVar_PyObject : SwigPtr_PyObject {
    3400             :     SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    3401             :     
    3402             :     SwigVar_PyObject & operator = (PyObject* obj)
    3403             :     {
    3404             :       Py_XDECREF(_obj);
    3405             :       _obj = obj;
    3406             :       return *this;      
    3407             :     }
    3408             :   };
    3409             : }
    3410             : 
    3411             : 
    3412             : #include <algorithm>
    3413             : #include <string>
    3414             : 
    3415             : 
    3416             : #include "lldb/lldb-public.h"
    3417             : #include "lldb/API/SBAddress.h"
    3418             : #include "lldb/API/SBAttachInfo.h"
    3419             : #include "lldb/API/SBBlock.h"
    3420             : #include "lldb/API/SBBreakpoint.h"
    3421             : #include "lldb/API/SBBreakpointLocation.h"
    3422             : #include "lldb/API/SBBreakpointName.h"
    3423             : #include "lldb/API/SBBroadcaster.h"
    3424             : #include "lldb/API/SBCommandInterpreter.h"
    3425             : #include "lldb/API/SBCommandReturnObject.h"
    3426             : #include "lldb/API/SBCommunication.h"
    3427             : #include "lldb/API/SBCompileUnit.h"
    3428             : #include "lldb/API/SBData.h"
    3429             : #include "lldb/API/SBDebugger.h"
    3430             : #include "lldb/API/SBDeclaration.h"
    3431             : #include "lldb/API/SBError.h"
    3432             : #include "lldb/API/SBEvent.h"
    3433             : #include "lldb/API/SBExecutionContext.h"
    3434             : #include "lldb/API/SBExpressionOptions.h"
    3435             : #include "lldb/API/SBFileSpec.h"
    3436             : #include "lldb/API/SBFileSpecList.h"
    3437             : #include "lldb/API/SBFrame.h"
    3438             : #include "lldb/API/SBFunction.h"
    3439             : #include "lldb/API/SBHostOS.h"
    3440             : #include "lldb/API/SBInstruction.h"
    3441             : #include "lldb/API/SBInstructionList.h"
    3442             : #include "lldb/API/SBLanguageRuntime.h"
    3443             : #include "lldb/API/SBLaunchInfo.h"
    3444             : #include "lldb/API/SBLineEntry.h"
    3445             : #include "lldb/API/SBListener.h"
    3446             : #include "lldb/API/SBMemoryRegionInfo.h"
    3447             : #include "lldb/API/SBMemoryRegionInfoList.h"
    3448             : #include "lldb/API/SBModule.h"
    3449             : #include "lldb/API/SBModuleSpec.h"
    3450             : #include "lldb/API/SBPlatform.h"
    3451             : #include "lldb/API/SBProcess.h"
    3452             : #include "lldb/API/SBProcessInfo.h"
    3453             : #include "lldb/API/SBQueue.h"
    3454             : #include "lldb/API/SBQueueItem.h"
    3455             : #include "lldb/API/SBSection.h"
    3456             : #include "lldb/API/SBSourceManager.h"
    3457             : #include "lldb/API/SBStream.h"
    3458             : #include "lldb/API/SBStringList.h"
    3459             : #include "lldb/API/SBStructuredData.h"
    3460             : #include "lldb/API/SBSymbol.h"
    3461             : #include "lldb/API/SBSymbolContext.h"
    3462             : #include "lldb/API/SBSymbolContextList.h"
    3463             : #include "lldb/API/SBTarget.h"
    3464             : #include "lldb/API/SBThread.h"
    3465             : #include "lldb/API/SBThreadCollection.h"
    3466             : #include "lldb/API/SBThreadPlan.h"
    3467             : #include "lldb/API/SBTrace.h"
    3468             : #include "lldb/API/SBTraceOptions.h"
    3469             : #include "lldb/API/SBType.h"
    3470             : #include "lldb/API/SBTypeCategory.h"
    3471             : #include "lldb/API/SBTypeEnumMember.h"
    3472             : #include "lldb/API/SBTypeFilter.h"
    3473             : #include "lldb/API/SBTypeFormat.h"
    3474             : #include "lldb/API/SBTypeNameSpecifier.h"
    3475             : #include "lldb/API/SBTypeSummary.h"
    3476             : #include "lldb/API/SBTypeSynthetic.h"
    3477             : #include "lldb/API/SBValue.h"
    3478             : #include "lldb/API/SBValueList.h"
    3479             : #include "lldb/API/SBVariablesOptions.h"
    3480             : #include "lldb/API/SBWatchpoint.h"
    3481             : #include "lldb/API/SBUnixSignals.h"
    3482             : 
    3483             : #include "../source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h"
    3484             : 
    3485             : #include "../scripts/Python/python-swigsafecast.swig"
    3486             : 
    3487             : 
    3488             : #include <stdint.h>               // Use the C99 official header
    3489             : 
    3490             : 
    3491             : SWIGINTERNINLINE PyObject*
    3492             :   SWIG_From_int  (int value)
    3493             : {
    3494      443150 :   return PyInt_FromLong((long) value);
    3495             : }
    3496             : 
    3497             : 
    3498             : SWIGINTERNINLINE PyObject*
    3499             :   SWIG_From_unsigned_SS_int  (unsigned int value)
    3500             : {
    3501       18128 :   return PyInt_FromSize_t((size_t) value);
    3502             : }
    3503             : 
    3504             : 
    3505             : #include <limits.h>
    3506             : #if !defined(SWIG_NO_LLONG_MAX)
    3507             : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
    3508             : #   define LLONG_MAX __LONG_LONG_MAX__
    3509             : #   define LLONG_MIN (-LLONG_MAX - 1LL)
    3510             : #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
    3511             : # endif
    3512             : #endif
    3513             : 
    3514             : 
    3515             : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
    3516             : #  define SWIG_LONG_LONG_AVAILABLE
    3517             : #endif
    3518             : 
    3519             : 
    3520             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3521             : SWIGINTERNINLINE PyObject* 
    3522       79124 : SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
    3523             : {
    3524       79124 :   return (value > LONG_MAX) ?
    3525       81788 :     PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
    3526             : }
    3527             : #endif
    3528             : 
    3529             : 
    3530             : SWIGINTERN swig_type_info*
    3531         420 : SWIG_pchar_descriptor(void)
    3532             : {
    3533             :   static int init = 0;
    3534             :   static swig_type_info* info = 0;
    3535         420 :   if (!init) {
    3536          46 :     info = SWIG_TypeQuery("_p_char");
    3537          46 :     init = 1;
    3538             :   }
    3539         420 :   return info;
    3540             : }
    3541             : 
    3542             : 
    3543             : SWIGINTERNINLINE PyObject *
    3544       33346 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
    3545             : {
    3546       33346 :   if (carray) {
    3547       21037 :     if (size > INT_MAX) {
    3548           0 :       swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    3549           0 :       return pchar_descriptor ? 
    3550           0 :         SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    3551             :     } else {
    3552             : #if PY_VERSION_HEX >= 0x03000000
    3553             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3554             :       return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
    3555             : #else
    3556             : #if PY_VERSION_HEX >= 0x03010000
    3557             :       return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
    3558             : #else
    3559             :       return PyUnicode_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
    3560             : #endif
    3561             : #endif
    3562             : #else
    3563       21037 :       return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
    3564             : #endif
    3565             :     }
    3566             :   } else {
    3567       12309 :     return SWIG_Py_Void();
    3568             :   }
    3569             : }
    3570             : 
    3571             : 
    3572             : SWIGINTERNINLINE PyObject * 
    3573       31348 : SWIG_FromCharPtr(const char *cptr)
    3574             : { 
    3575       33346 :   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
    3576             : }
    3577             : 
    3578             : 
    3579             : SWIGINTERNINLINE PyObject*
    3580             :   SWIG_From_bool  (bool value)
    3581             : {
    3582       32368 :   return PyBool_FromLong(value ? 1 : 0);
    3583             : }
    3584             : 
    3585             : 
    3586             : SWIGINTERN int
    3587           2 : SWIG_AsVal_double (PyObject *obj, double *val)
    3588             : {
    3589             :   int res = SWIG_TypeError;
    3590           2 :   if (PyFloat_Check(obj)) {
    3591           2 :     if (val) *val = PyFloat_AsDouble(obj);
    3592           2 :     return SWIG_OK;
    3593             : #if PY_VERSION_HEX < 0x03000000
    3594           0 :   } else if (PyInt_Check(obj)) {
    3595           0 :     if (val) *val = (double) PyInt_AsLong(obj);
    3596           0 :     return SWIG_OK;
    3597             : #endif
    3598           0 :   } else if (PyLong_Check(obj)) {
    3599           0 :     double v = PyLong_AsDouble(obj);
    3600           0 :     if (!PyErr_Occurred()) {
    3601           0 :       if (val) *val = v;
    3602           0 :       return SWIG_OK;
    3603             :     } else {
    3604           0 :       PyErr_Clear();
    3605             :     }
    3606             :   }
    3607             : #ifdef SWIG_PYTHON_CAST_MODE
    3608             :   {
    3609             :     int dispatch = 0;
    3610             :     double d = PyFloat_AsDouble(obj);
    3611             :     if (!PyErr_Occurred()) {
    3612             :       if (val) *val = d;
    3613             :       return SWIG_AddCast(SWIG_OK);
    3614             :     } else {
    3615             :       PyErr_Clear();
    3616             :     }
    3617             :     if (!dispatch) {
    3618             :       long v = PyLong_AsLong(obj);
    3619             :       if (!PyErr_Occurred()) {
    3620             :         if (val) *val = v;
    3621             :         return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
    3622             :       } else {
    3623             :         PyErr_Clear();
    3624             :       }
    3625             :     }
    3626             :   }
    3627             : #endif
    3628             :   return res;
    3629             : }
    3630             : 
    3631             : 
    3632             : #include <float.h>
    3633             : 
    3634             : 
    3635             : #include <math.h>
    3636             : 
    3637             : 
    3638             : SWIGINTERNINLINE int
    3639             : SWIG_CanCastAsInteger(double *d, double min, double max) {
    3640             :   double x = *d;
    3641             :   if ((min <= x && x <= max)) {
    3642             :    double fx = floor(x);
    3643             :    double cx = ceil(x);
    3644             :    double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
    3645             :    if ((errno == EDOM) || (errno == ERANGE)) {
    3646             :      errno = 0;
    3647             :    } else {
    3648             :      double summ, reps, diff;
    3649             :      if (rd < x) {
    3650             :        diff = x - rd;
    3651             :      } else if (rd > x) {
    3652             :        diff = rd - x;
    3653             :      } else {
    3654             :        return 1;
    3655             :      }
    3656             :      summ = rd + x;
    3657             :      reps = diff/summ;
    3658             :      if (reps < 8*DBL_EPSILON) {
    3659             :        *d = rd;
    3660             :        return 1;
    3661             :      }
    3662             :    }
    3663             :   }
    3664             :   return 0;
    3665             : }
    3666             : 
    3667             : 
    3668             : SWIGINTERN int
    3669       23383 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
    3670             : {
    3671             : #if PY_VERSION_HEX < 0x03000000
    3672       23383 :   if (PyInt_Check(obj)) {
    3673       23383 :     long v = PyInt_AsLong(obj);
    3674       23383 :     if (v >= 0) {
    3675       23383 :       if (val) *val = v;
    3676       23383 :       return SWIG_OK;
    3677             :     } else {
    3678             :       return SWIG_OverflowError;
    3679             :     }
    3680             :   } else
    3681             : #endif
    3682           0 :   if (PyLong_Check(obj)) {
    3683           0 :     unsigned long v = PyLong_AsUnsignedLong(obj);
    3684           0 :     if (!PyErr_Occurred()) {
    3685           0 :       if (val) *val = v;
    3686           0 :       return SWIG_OK;
    3687             :     } else {
    3688           0 :       PyErr_Clear();
    3689           0 :       return SWIG_OverflowError;
    3690             :     }
    3691             :   }
    3692             : #ifdef SWIG_PYTHON_CAST_MODE
    3693             :   {
    3694             :     int dispatch = 0;
    3695             :     unsigned long v = PyLong_AsUnsignedLong(obj);
    3696             :     if (!PyErr_Occurred()) {
    3697             :       if (val) *val = v;
    3698             :       return SWIG_AddCast(SWIG_OK);
    3699             :     } else {
    3700             :       PyErr_Clear();
    3701             :     }
    3702             :     if (!dispatch) {
    3703             :       double d;
    3704             :       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
    3705             :       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
    3706             :         if (val) *val = (unsigned long)(d);
    3707             :         return res;
    3708             :       }
    3709             :     }
    3710             :   }
    3711             : #endif
    3712             :   return SWIG_TypeError;
    3713             : }
    3714             : 
    3715             : 
    3716             : #ifdef SWIG_LONG_LONG_AVAILABLE
    3717             : SWIGINTERN int
    3718         263 : SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
    3719             : {
    3720             :   int res = SWIG_TypeError;
    3721         263 :   if (PyLong_Check(obj)) {
    3722          15 :     unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    3723          15 :     if (!PyErr_Occurred()) {
    3724          15 :       if (val) *val = v;
    3725          15 :       return SWIG_OK;
    3726             :     } else {
    3727           0 :       PyErr_Clear();
    3728             :       res = SWIG_OverflowError;
    3729             :     }
    3730             :   } else {
    3731             :     unsigned long v;
    3732         248 :     res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    3733         248 :     if (SWIG_IsOK(res)) {
    3734         248 :       if (val) *val = v;
    3735         248 :       return res;
    3736             :     }
    3737             :   }
    3738             : #ifdef SWIG_PYTHON_CAST_MODE
    3739             :   {
    3740             :     const double mant_max = 1LL << DBL_MANT_DIG;
    3741             :     double d;
    3742             :     res = SWIG_AsVal_double (obj,&d);
    3743             :     if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
    3744             :       return SWIG_OverflowError;
    3745             :     if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
    3746             :       if (val) *val = (unsigned long long)(d);
    3747             :       return SWIG_AddCast(res);
    3748             :     }
    3749             :     res = SWIG_TypeError;
    3750             :   }
    3751             : #endif
    3752             :   return res;
    3753             : }
    3754             : #endif
    3755             : 
    3756             : 
    3757             : SWIGINTERN int
    3758             : SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
    3759             : {
    3760             :   unsigned long v;
    3761        2028 :   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
    3762        2028 :   if (SWIG_IsOK(res)) {
    3763        2028 :     if ((v > UINT_MAX)) {
    3764             :       return SWIG_OverflowError;
    3765             :     } else {
    3766        1699 :       if (val) *val = static_cast< unsigned int >(v);
    3767             :     }
    3768             :   }  
    3769             :   return res;
    3770             : }
    3771             : 
    3772           0 : SWIGINTERN PyObject *lldb_SBAddress___str__(lldb::SBAddress *self){
    3773           0 :                 lldb::SBStream description;
    3774           0 :                 self->GetDescription (description);
    3775           0 :                 const char *desc = description.GetData();
    3776           0 :                 size_t desc_len = description.GetSize();
    3777           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    3778             :                     --desc_len;
    3779           0 :                 if (desc_len > 0)
    3780           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    3781             :                 else
    3782           0 :                     return lldb_private::PythonString("").release();
    3783             :         }
    3784             : 
    3785             : SWIGINTERN int
    3786       17780 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
    3787             : {
    3788             : #if PY_VERSION_HEX>=0x03000000
    3789             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3790             :   if (PyBytes_Check(obj))
    3791             : #else
    3792             :   if (PyUnicode_Check(obj))
    3793             : #endif
    3794             : #else  
    3795       17780 :   if (PyString_Check(obj))
    3796             : #endif
    3797             :   {
    3798             :     char *cstr; Py_ssize_t len;
    3799             : #if PY_VERSION_HEX>=0x03000000
    3800             : #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3801             :     if (!alloc && cptr) {
    3802             :         /* We can't allow converting without allocation, since the internal
    3803             :            representation of string in Python 3 is UCS-2/UCS-4 but we require
    3804             :            a UTF-8 representation.
    3805             :            TODO(bhy) More detailed explanation */
    3806             :         return SWIG_RuntimeError;
    3807             :     }
    3808             :     obj = PyUnicode_AsUTF8String(obj);
    3809             :     if(alloc) *alloc = SWIG_NEWOBJ;
    3810             : #endif
    3811             :     PyBytes_AsStringAndSize(obj, &cstr, &len);
    3812             : #else
    3813       17360 :     PyString_AsStringAndSize(obj, &cstr, &len);
    3814             : #endif
    3815       17360 :     if (cptr) {
    3816        9182 :       if (alloc) {
    3817             :         /* 
    3818             :            In python the user should not be able to modify the inner
    3819             :            string representation. To warranty that, if you define
    3820             :            SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
    3821             :            buffer is always returned.
    3822             : 
    3823             :            The default behavior is just to return the pointer value,
    3824             :            so, be careful.
    3825             :         */ 
    3826             : #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
    3827             :         if (*alloc != SWIG_OLDOBJ) 
    3828             : #else
    3829        9182 :         if (*alloc == SWIG_NEWOBJ) 
    3830             : #endif
    3831             :         {
    3832           0 :           *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
    3833           0 :           *alloc = SWIG_NEWOBJ;
    3834             :         } else {
    3835        9182 :           *cptr = cstr;
    3836        9182 :           *alloc = SWIG_OLDOBJ;
    3837             :         }
    3838             :       } else {
    3839             : #if PY_VERSION_HEX>=0x03000000
    3840             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3841             :         *cptr = PyBytes_AsString(obj);
    3842             : #else
    3843             :         assert(0); /* Should never reach here with Unicode strings in Python 3 */
    3844             : #endif
    3845             : #else
    3846           0 :         *cptr = SWIG_Python_str_AsChar(obj);
    3847             : #endif
    3848             :       }
    3849             :     }
    3850       17360 :     if (psize) *psize = len + 1;
    3851             : #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3852             :     Py_XDECREF(obj);
    3853             : #endif
    3854             :     return SWIG_OK;
    3855             :   } else {
    3856             : #if defined(SWIG_PYTHON_2_UNICODE)
    3857             : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    3858             : #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
    3859             : #endif
    3860             : #if PY_VERSION_HEX<0x03000000
    3861             :     if (PyUnicode_Check(obj)) {
    3862             :       char *cstr; Py_ssize_t len;
    3863             :       if (!alloc && cptr) {
    3864             :         return SWIG_RuntimeError;
    3865             :       }
    3866             :       obj = PyUnicode_AsUTF8String(obj);
    3867             :       if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
    3868             :         if (cptr) {
    3869             :           if (alloc) *alloc = SWIG_NEWOBJ;
    3870             :           *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
    3871             :         }
    3872             :         if (psize) *psize = len + 1;
    3873             : 
    3874             :         Py_XDECREF(obj);
    3875             :         return SWIG_OK;
    3876             :       } else {
    3877             :         Py_XDECREF(obj);
    3878             :       }
    3879             :     }
    3880             : #endif
    3881             : #endif
    3882             : 
    3883         420 :     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    3884         420 :     if (pchar_descriptor) {
    3885         420 :       void* vptr = 0;
    3886         420 :       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
    3887         420 :         if (cptr) *cptr = (char *) vptr;
    3888         420 :         if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
    3889         420 :         if (alloc) *alloc = SWIG_OLDOBJ;
    3890         420 :         return SWIG_OK;
    3891             :       }
    3892             :     }
    3893             :   }
    3894             :   return SWIG_TypeError;
    3895             : }
    3896             : 
    3897             : 
    3898             : 
    3899             : 
    3900             : 
    3901             : SWIGINTERN int
    3902         811 : SWIG_AsVal_long (PyObject *obj, long* val)
    3903             : {
    3904             : #if PY_VERSION_HEX < 0x03000000
    3905         811 :   if (PyInt_Check(obj)) {
    3906         811 :     if (val) *val = PyInt_AsLong(obj);
    3907         811 :     return SWIG_OK;
    3908             :   } else
    3909             : #endif
    3910           0 :   if (PyLong_Check(obj)) {
    3911           0 :     long v = PyLong_AsLong(obj);
    3912           0 :     if (!PyErr_Occurred()) {
    3913           0 :       if (val) *val = v;
    3914           0 :       return SWIG_OK;
    3915             :     } else {
    3916           0 :       PyErr_Clear();
    3917           0 :       return SWIG_OverflowError;
    3918             :     }
    3919             :   }
    3920             : #ifdef SWIG_PYTHON_CAST_MODE
    3921             :   {
    3922             :     int dispatch = 0;
    3923             :     long v = PyInt_AsLong(obj);
    3924             :     if (!PyErr_Occurred()) {
    3925             :       if (val) *val = v;
    3926             :       return SWIG_AddCast(SWIG_OK);
    3927             :     } else {
    3928             :       PyErr_Clear();
    3929             :     }
    3930             :     if (!dispatch) {
    3931             :       double d;
    3932             :       int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
    3933             :       if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
    3934             :         if (val) *val = (long)(d);
    3935             :         return res;
    3936             :       }
    3937             :     }
    3938             :   }
    3939             : #endif
    3940             :   return SWIG_TypeError;
    3941             : }
    3942             : 
    3943             : 
    3944             : SWIGINTERN int
    3945             : SWIG_AsVal_bool (PyObject *obj, bool *val)
    3946             : {
    3947             :   int r;
    3948        8045 :   if (!PyBool_Check(obj))
    3949             :     return SWIG_ERROR;
    3950        8045 :   r = PyObject_IsTrue(obj);
    3951        8045 :   if (r == -1)
    3952             :     return SWIG_ERROR;
    3953        1694 :   if (val) *val = r ? true : false;
    3954             :   return SWIG_OK;
    3955             : }
    3956             : 
    3957             : 
    3958             : SWIGINTERN int
    3959             : SWIG_AsVal_int (PyObject * obj, int *val)
    3960             : {
    3961             :   long v;
    3962         741 :   int res = SWIG_AsVal_long (obj, &v);
    3963         741 :   if (SWIG_IsOK(res)) {
    3964         741 :     if ((v < INT_MIN || v > INT_MAX)) {
    3965             :       return SWIG_OverflowError;
    3966             :     } else {
    3967         676 :       if (val) *val = static_cast< int >(v);
    3968             :     }
    3969             :   }  
    3970             :   return res;
    3971             : }
    3972             : 
    3973           0 : SWIGINTERN PyObject *lldb_SBBlock___str__(lldb::SBBlock *self){
    3974           0 :                 lldb::SBStream description;
    3975           0 :                 self->GetDescription (description);
    3976           0 :                 const char *desc = description.GetData();
    3977           0 :                 size_t desc_len = description.GetSize();
    3978           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    3979             :                     --desc_len;
    3980           0 :                 if (desc_len > 0)
    3981           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    3982             :                 else
    3983           0 :                     return lldb_private::PythonString("").release();
    3984             :         }
    3985             : 
    3986             :   #define SWIG_From_long   PyInt_FromLong 
    3987             : 
    3988             : 
    3989             : SWIGINTERNINLINE PyObject* 
    3990         813 : SWIG_From_unsigned_SS_long  (unsigned long value)
    3991             : {
    3992         813 :   return (value > LONG_MAX) ?
    3993         813 :     PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
    3994             : }
    3995             : 
    3996             : 
    3997             : SWIGINTERNINLINE PyObject *
    3998             : SWIG_From_size_t  (size_t value)
    3999             : {    
    4000             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4001             :   if (sizeof(size_t) <= sizeof(unsigned long)) {
    4002             : #endif
    4003         813 :     return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
    4004             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4005             :   } else {
    4006             :     /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    4007             :     return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
    4008             :   }
    4009             : #endif
    4010             : }
    4011             : 
    4012           8 : SWIGINTERN PyObject *lldb_SBBreakpoint___str__(lldb::SBBreakpoint *self){
    4013          16 :                 lldb::SBStream description;
    4014           8 :                 self->GetDescription (description);
    4015           8 :                 const char *desc = description.GetData();
    4016           8 :                 size_t desc_len = description.GetSize();
    4017           8 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4018             :                     --desc_len;
    4019           8 :                 if (desc_len > 0)
    4020           8 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4021             :                 else
    4022           0 :                     return lldb_private::PythonString("").release();
    4023             :         }
    4024             : 
    4025             : SWIGINTERNINLINE int
    4026             : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
    4027             : {
    4028             :   int res = SWIG_TypeError;
    4029             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4030             :   if (sizeof(size_t) <= sizeof(unsigned long)) {
    4031             : #endif
    4032             :     unsigned long v;
    4033       20770 :     res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    4034       20770 :     if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
    4035             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4036             :   } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    4037             :     unsigned long long v;
    4038             :     res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    4039             :     if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
    4040             :   }
    4041             : #endif
    4042             :   return res;
    4043             : }
    4044             : 
    4045           0 : SWIGINTERN PyObject *lldb_SBBreakpointLocation___str__(lldb::SBBreakpointLocation *self){
    4046           0 :                 lldb::SBStream description;
    4047           0 :                 self->GetDescription (description, lldb::eDescriptionLevelFull);
    4048           0 :                 const char *desc = description.GetData();
    4049           0 :                 size_t desc_len = description.GetSize();
    4050           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4051             :                     --desc_len;
    4052           0 :                 if (desc_len > 0)
    4053           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4054             :                 else
    4055           0 :                     return lldb_private::PythonString("").release();
    4056             :         }
    4057           0 : SWIGINTERN PyObject *lldb_SBBreakpointName___str__(lldb::SBBreakpointName *self){
    4058           0 :                 lldb::SBStream description;
    4059           0 :                 self->GetDescription (description);
    4060           0 :                 const char *desc = description.GetData();
    4061           0 :                 size_t desc_len = description.GetSize();
    4062           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4063             :                     --desc_len;
    4064           0 :                 if (desc_len > 0)
    4065           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4066             :                 else
    4067           0 :                     return lldb_private::PythonString("").release();
    4068             :         }
    4069             : 
    4070             : SWIGINTERN int
    4071           0 : SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
    4072             : { 
    4073           0 :   char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
    4074           0 :   int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
    4075           0 :   if (SWIG_IsOK(res)) {
    4076             :     /* special case of single char conversion when we don't need space for NUL */
    4077           0 :     if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    4078           0 :     if (csize <= size) {
    4079           0 :       if (val) {
    4080           0 :         if (csize) memcpy(val, cptr, csize*sizeof(char));
    4081           0 :         if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
    4082             :       }
    4083           0 :       if (alloc == SWIG_NEWOBJ) {
    4084           0 :         delete[] cptr;
    4085           0 :         res = SWIG_DelNewMask(res);
    4086             :       }      
    4087           0 :       return res;
    4088             :     }
    4089           0 :     if (alloc == SWIG_NEWOBJ) delete[] cptr;
    4090             :   }
    4091             :   return SWIG_TypeError;
    4092             : }
    4093             : 
    4094             : 
    4095             : SWIGINTERN int
    4096           0 : SWIG_AsVal_char (PyObject * obj, char *val)
    4097             : {    
    4098           0 :   int res = SWIG_AsCharArray(obj, val, 1);
    4099           0 :   if (!SWIG_IsOK(res)) {
    4100             :     long v;
    4101           0 :     res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    4102           0 :     if (SWIG_IsOK(res)) {
    4103           0 :       if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
    4104           0 :         if (val) *val = static_cast< char >(v);
    4105             :       } else {
    4106             :         res = SWIG_OverflowError;
    4107             :       }
    4108             :     }
    4109             :   }
    4110           0 :   return res;
    4111             : }
    4112             : 
    4113             : SWIGINTERN void lldb_SBCommandReturnObject_SetImmediateOutputFile(lldb::SBCommandReturnObject *self,FILE *fh){
    4114           1 :             self->SetImmediateOutputFile(fh, true);
    4115             :         }
    4116             : SWIGINTERN void lldb_SBCommandReturnObject_SetImmediateErrorFile(lldb::SBCommandReturnObject *self,FILE *fh){
    4117           0 :             self->SetImmediateErrorFile(fh, true);
    4118             :         }
    4119             : SWIGINTERN void lldb_SBCommandReturnObject_Print(lldb::SBCommandReturnObject *self,char const *str){
    4120           0 :             self->Printf("%s", str);
    4121             :         }
    4122           2 : SWIGINTERN PyObject *lldb_SBCommandReturnObject___str__(lldb::SBCommandReturnObject *self){
    4123           4 :                 lldb::SBStream description;
    4124           2 :                 self->GetDescription (description);
    4125           2 :                 const char *desc = description.GetData();
    4126           2 :                 size_t desc_len = description.GetSize();
    4127           2 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4128             :                     --desc_len;
    4129           2 :                 if (desc_len > 0)
    4130           2 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4131             :                 else
    4132           0 :                     return lldb_private::PythonString("").release();
    4133             :         }
    4134             : SWIGINTERN void lldb_SBCommandReturnObject_write(lldb::SBCommandReturnObject *self,char const *str){
    4135          34 :             if (str)
    4136          34 :                 self->Printf("%s",str);
    4137             :         }
    4138           0 : SWIGINTERN void lldb_SBCommandReturnObject_flush(lldb::SBCommandReturnObject *self){}
    4139           6 : SWIGINTERN PyObject *lldb_SBCompileUnit___str__(lldb::SBCompileUnit *self){
    4140          12 :                 lldb::SBStream description;
    4141           6 :                 self->GetDescription (description);
    4142           6 :                 const char *desc = description.GetData();
    4143           6 :                 size_t desc_len = description.GetSize();
    4144           6 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4145             :                     --desc_len;
    4146           6 :                 if (desc_len > 0)
    4147           6 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4148             :                 else
    4149           0 :                     return lldb_private::PythonString("").release();
    4150             :         }
    4151             : 
    4152             : SWIGINTERNINLINE PyObject *
    4153             : SWIG_From_unsigned_SS_char  (unsigned char value)
    4154             : {    
    4155           0 :   return SWIG_From_unsigned_SS_long  (value);
    4156             : }
    4157             : 
    4158             : 
    4159             : SWIGINTERN int
    4160             : SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
    4161             : {
    4162             :   unsigned long v;
    4163           8 :   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
    4164           8 :   if (SWIG_IsOK(res)) {
    4165           8 :     if ((v > UCHAR_MAX)) {
    4166             :       return SWIG_OverflowError;
    4167             :     } else {
    4168           8 :       if (val) *val = static_cast< unsigned char >(v);
    4169             :     }
    4170             :   }  
    4171             :   return res;
    4172             : }
    4173             : 
    4174             : 
    4175             :   #define SWIG_From_double   PyFloat_FromDouble 
    4176             : 
    4177             : 
    4178             : SWIGINTERNINLINE PyObject *
    4179             : SWIG_From_float  (float value)
    4180             : {    
    4181           0 :   return SWIG_From_double  (value);
    4182             : }
    4183             : 
    4184             : 
    4185             : SWIGINTERNINLINE PyObject *
    4186             : SWIG_From_unsigned_SS_short  (unsigned short value)
    4187             : {    
    4188           0 :   return SWIG_From_unsigned_SS_long  (value);
    4189             : }
    4190             : 
    4191             : 
    4192             : SWIGINTERNINLINE PyObject *
    4193             : SWIG_From_signed_SS_char  (signed char value)
    4194             : {    
    4195           0 :   return SWIG_From_long  (value);
    4196             : }
    4197             : 
    4198             : 
    4199             : SWIGINTERNINLINE PyObject *
    4200             : SWIG_From_short  (short value)
    4201             : {    
    4202           0 :   return SWIG_From_long  (value);
    4203             : }
    4204             : 
    4205             : 
    4206             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4207             : SWIGINTERNINLINE PyObject* 
    4208             : SWIG_From_long_SS_long  (long long value)
    4209             : {
    4210           0 :   return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    4211             :     PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
    4212             : }
    4213             : #endif
    4214             : 
    4215           0 : SWIGINTERN PyObject *lldb_SBData___str__(lldb::SBData *self){
    4216           0 :                 lldb::SBStream description;
    4217           0 :                 self->GetDescription (description);
    4218           0 :                 const char *desc = description.GetData();
    4219           0 :                 size_t desc_len = description.GetSize();
    4220           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4221             :                     --desc_len;
    4222           0 :                 if (desc_len > 0)
    4223           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4224             :                 else
    4225           0 :                     return lldb_private::PythonString("").release();
    4226             :         }
    4227           0 : SWIGINTERN PyObject *lldb_SBDebugger___str__(lldb::SBDebugger *self){
    4228           0 :                 lldb::SBStream description;
    4229           0 :                 self->GetDescription (description);
    4230           0 :                 const char *desc = description.GetData();
    4231           0 :                 size_t desc_len = description.GetSize();
    4232           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4233             :                     --desc_len;
    4234           0 :                 if (desc_len > 0)
    4235           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4236             :                 else
    4237           0 :                     return lldb_private::PythonString("").release();
    4238             :         }
    4239           0 : SWIGINTERN PyObject *lldb_SBDeclaration___str__(lldb::SBDeclaration *self){
    4240           0 :                 lldb::SBStream description;
    4241           0 :                 self->GetDescription (description);
    4242           0 :                 const char *desc = description.GetData();
    4243           0 :                 size_t desc_len = description.GetSize();
    4244           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4245             :                     --desc_len;
    4246           0 :                 if (desc_len > 0)
    4247           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4248             :                 else
    4249           0 :                     return lldb_private::PythonString("").release();
    4250             :         }
    4251         959 : SWIGINTERN PyObject *lldb_SBError___str__(lldb::SBError *self){
    4252        1918 :                 lldb::SBStream description;
    4253         959 :                 self->GetDescription (description);
    4254         959 :                 const char *desc = description.GetData();
    4255         959 :                 size_t desc_len = description.GetSize();
    4256         959 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4257             :                     --desc_len;
    4258         959 :                 if (desc_len > 0)
    4259         959 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4260             :                 else
    4261           0 :                     return lldb_private::PythonString("").release();
    4262             :         }
    4263           0 : SWIGINTERN PyObject *lldb_SBFileSpec___str__(lldb::SBFileSpec *self){
    4264           0 :                 lldb::SBStream description;
    4265           0 :                 self->GetDescription (description);
    4266           0 :                 const char *desc = description.GetData();
    4267           0 :                 size_t desc_len = description.GetSize();
    4268           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4269             :                     --desc_len;
    4270           0 :                 if (desc_len > 0)
    4271           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4272             :                 else
    4273           0 :                     return lldb_private::PythonString("").release();
    4274             :         }
    4275           0 : SWIGINTERN PyObject *lldb_SBFrame___str__(lldb::SBFrame *self){
    4276           0 :                 lldb::SBStream description;
    4277           0 :                 self->GetDescription (description);
    4278           0 :                 const char *desc = description.GetData();
    4279           0 :                 size_t desc_len = description.GetSize();
    4280           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4281             :                     --desc_len;
    4282           0 :                 if (desc_len > 0)
    4283           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4284             :                 else
    4285           0 :                     return lldb_private::PythonString("").release();
    4286             :         }
    4287           0 : SWIGINTERN PyObject *lldb_SBFunction___str__(lldb::SBFunction *self){
    4288           0 :                 lldb::SBStream description;
    4289           0 :                 self->GetDescription (description);
    4290           0 :                 const char *desc = description.GetData();
    4291           0 :                 size_t desc_len = description.GetSize();
    4292           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4293             :                     --desc_len;
    4294           0 :                 if (desc_len > 0)
    4295           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4296             :                 else
    4297           0 :                     return lldb_private::PythonString("").release();
    4298             :         }
    4299           0 : SWIGINTERN PyObject *lldb_SBInstruction___str__(lldb::SBInstruction *self){
    4300           0 :                 lldb::SBStream description;
    4301           0 :                 self->GetDescription (description);
    4302           0 :                 const char *desc = description.GetData();
    4303           0 :                 size_t desc_len = description.GetSize();
    4304           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4305             :                     --desc_len;
    4306           0 :                 if (desc_len > 0)
    4307           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4308             :                 else
    4309           0 :                     return lldb_private::PythonString("").release();
    4310             :         }
    4311           0 : SWIGINTERN PyObject *lldb_SBInstructionList___str__(lldb::SBInstructionList *self){
    4312           0 :                 lldb::SBStream description;
    4313           0 :                 self->GetDescription (description);
    4314           0 :                 const char *desc = description.GetData();
    4315           0 :                 size_t desc_len = description.GetSize();
    4316           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4317             :                     --desc_len;
    4318           0 :                 if (desc_len > 0)
    4319           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4320             :                 else
    4321           0 :                     return lldb_private::PythonString("").release();
    4322             :         }
    4323           0 : SWIGINTERN PyObject *lldb_SBLineEntry___str__(lldb::SBLineEntry *self){
    4324           0 :                 lldb::SBStream description;
    4325           0 :                 self->GetDescription (description);
    4326           0 :                 const char *desc = description.GetData();
    4327           0 :                 size_t desc_len = description.GetSize();
    4328           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4329             :                     --desc_len;
    4330           0 :                 if (desc_len > 0)
    4331           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4332             :                 else
    4333           0 :                     return lldb_private::PythonString("").release();
    4334             :         }
    4335           0 : SWIGINTERN PyObject *lldb_SBMemoryRegionInfo___str__(lldb::SBMemoryRegionInfo *self){
    4336           0 :                 lldb::SBStream description;
    4337           0 :                 self->GetDescription (description);
    4338           0 :                 const char *desc = description.GetData();
    4339           0 :                 size_t desc_len = description.GetSize();
    4340           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4341             :                     --desc_len;
    4342           0 :                 if (desc_len > 0)
    4343           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4344             :                 else
    4345           0 :                     return lldb_private::PythonString("").release();
    4346             :         }
    4347          12 : SWIGINTERN PyObject *lldb_SBModule___str__(lldb::SBModule *self){
    4348          24 :                 lldb::SBStream description;
    4349          12 :                 self->GetDescription (description);
    4350          12 :                 const char *desc = description.GetData();
    4351          12 :                 size_t desc_len = description.GetSize();
    4352          12 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4353             :                     --desc_len;
    4354          12 :                 if (desc_len > 0)
    4355          12 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4356             :                 else
    4357           0 :                     return lldb_private::PythonString("").release();
    4358             :         }
    4359           0 : SWIGINTERN PyObject *lldb_SBModuleSpec___str__(lldb::SBModuleSpec *self){
    4360           0 :                 lldb::SBStream description;
    4361           0 :                 self->GetDescription (description);
    4362           0 :                 const char *desc = description.GetData();
    4363           0 :                 size_t desc_len = description.GetSize();
    4364           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4365             :                     --desc_len;
    4366           0 :                 if (desc_len > 0)
    4367           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4368             :                 else
    4369           0 :                     return lldb_private::PythonString("").release();
    4370             :         }
    4371           0 : SWIGINTERN PyObject *lldb_SBModuleSpecList___str__(lldb::SBModuleSpecList *self){
    4372           0 :                 lldb::SBStream description;
    4373           0 :                 self->GetDescription (description);
    4374           0 :                 const char *desc = description.GetData();
    4375           0 :                 size_t desc_len = description.GetSize();
    4376           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4377             :                     --desc_len;
    4378           0 :                 if (desc_len > 0)
    4379           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4380             :                 else
    4381           0 :                     return lldb_private::PythonString("").release();
    4382             :         }
    4383         960 : SWIGINTERN PyObject *lldb_SBProcess___str__(lldb::SBProcess *self){
    4384        1920 :                 lldb::SBStream description;
    4385         960 :                 self->GetDescription (description);
    4386         960 :                 const char *desc = description.GetData();
    4387         960 :                 size_t desc_len = description.GetSize();
    4388         960 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4389             :                     --desc_len;
    4390         960 :                 if (desc_len > 0)
    4391         960 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4392             :                 else
    4393           0 :                     return lldb_private::PythonString("").release();
    4394             :         }
    4395          79 : SWIGINTERN PyObject *lldb_SBSection___str__(lldb::SBSection *self){
    4396         158 :                 lldb::SBStream description;
    4397          79 :                 self->GetDescription (description);
    4398          79 :                 const char *desc = description.GetData();
    4399          79 :                 size_t desc_len = description.GetSize();
    4400          79 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4401             :                     --desc_len;
    4402          79 :                 if (desc_len > 0)
    4403          79 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4404             :                 else
    4405           0 :                     return lldb_private::PythonString("").release();
    4406             :         }
    4407             : SWIGINTERN void lldb_SBStream_Print(lldb::SBStream *self,char const *str){
    4408           9 :             self->Printf("%s", str);
    4409             :         }
    4410             : SWIGINTERN void lldb_SBStream_write(lldb::SBStream *self,char const *str){
    4411           0 :             if (str)
    4412           0 :                 self->Printf("%s",str);
    4413             :         }
    4414           0 : SWIGINTERN void lldb_SBStream_flush(lldb::SBStream *self){}
    4415         434 : SWIGINTERN PyObject *lldb_SBSymbol___str__(lldb::SBSymbol *self){
    4416         868 :                 lldb::SBStream description;
    4417         434 :                 self->GetDescription (description);
    4418         434 :                 const char *desc = description.GetData();
    4419         434 :                 size_t desc_len = description.GetSize();
    4420         434 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4421             :                     --desc_len;
    4422         434 :                 if (desc_len > 0)
    4423         434 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4424             :                 else
    4425           0 :                     return lldb_private::PythonString("").release();
    4426             :         }
    4427           0 : SWIGINTERN PyObject *lldb_SBSymbolContext___str__(lldb::SBSymbolContext *self){
    4428           0 :                 lldb::SBStream description;
    4429           0 :                 self->GetDescription (description);
    4430           0 :                 const char *desc = description.GetData();
    4431           0 :                 size_t desc_len = description.GetSize();
    4432           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4433             :                     --desc_len;
    4434           0 :                 if (desc_len > 0)
    4435           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4436             :                 else
    4437           0 :                     return lldb_private::PythonString("").release();
    4438             :         }
    4439           0 : SWIGINTERN PyObject *lldb_SBSymbolContextList___str__(lldb::SBSymbolContextList *self){
    4440           0 :                 lldb::SBStream description;
    4441           0 :                 self->GetDescription (description);
    4442           0 :                 const char *desc = description.GetData();
    4443           0 :                 size_t desc_len = description.GetSize();
    4444           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4445             :                     --desc_len;
    4446           0 :                 if (desc_len > 0)
    4447           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4448             :                 else
    4449           0 :                     return lldb_private::PythonString("").release();
    4450             :         }
    4451             : 
    4452             : #ifdef SWIG_LONG_LONG_AVAILABLE
    4453             : SWIGINTERN int
    4454           5 : SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
    4455             : {
    4456             :   int res = SWIG_TypeError;
    4457           5 :   if (PyLong_Check(obj)) {
    4458           0 :     long long v = PyLong_AsLongLong(obj);
    4459           0 :     if (!PyErr_Occurred()) {
    4460           0 :       if (val) *val = v;
    4461           0 :       return SWIG_OK;
    4462             :     } else {
    4463           0 :       PyErr_Clear();
    4464             :       res = SWIG_OverflowError;
    4465             :     }
    4466             :   } else {
    4467             :     long v;
    4468           5 :     res = SWIG_AsVal_long (obj,&v);
    4469           5 :     if (SWIG_IsOK(res)) {
    4470           5 :       if (val) *val = v;
    4471           5 :       return res;
    4472             :     }
    4473             :   }
    4474             : #ifdef SWIG_PYTHON_CAST_MODE
    4475             :   {
    4476             :     const double mant_max = 1LL << DBL_MANT_DIG;
    4477             :     const double mant_min = -mant_max;
    4478             :     double d;
    4479             :     res = SWIG_AsVal_double (obj,&d);
    4480             :     if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
    4481             :       return SWIG_OverflowError;
    4482             :     if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
    4483             :       if (val) *val = (long long)(d);
    4484             :       return SWIG_AddCast(res);
    4485             :     }
    4486             :     res = SWIG_TypeError;
    4487             :   }
    4488             : #endif
    4489             :   return res;
    4490             : }
    4491             : #endif
    4492             : 
    4493           0 : SWIGINTERN PyObject *lldb_SBTarget___str__(lldb::SBTarget *self){
    4494           0 :                 lldb::SBStream description;
    4495           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4496           0 :                 const char *desc = description.GetData();
    4497           0 :                 size_t desc_len = description.GetSize();
    4498           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4499             :                     --desc_len;
    4500           0 :                 if (desc_len > 0)
    4501           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4502             :                 else
    4503           0 :                     return lldb_private::PythonString("").release();
    4504             :         }
    4505           0 : SWIGINTERN PyObject *lldb_SBThread___str__(lldb::SBThread *self){
    4506           0 :                 lldb::SBStream description;
    4507           0 :                 self->GetDescription (description);
    4508           0 :                 const char *desc = description.GetData();
    4509           0 :                 size_t desc_len = description.GetSize();
    4510           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4511             :                     --desc_len;
    4512           0 :                 if (desc_len > 0)
    4513           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4514             :                 else
    4515           0 :                     return lldb_private::PythonString("").release();
    4516             :         }
    4517           0 : SWIGINTERN PyObject *lldb_SBTypeMember___str__(lldb::SBTypeMember *self){
    4518           0 :                 lldb::SBStream description;
    4519           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4520           0 :                 const char *desc = description.GetData();
    4521           0 :                 size_t desc_len = description.GetSize();
    4522           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4523             :                     --desc_len;
    4524           0 :                 if (desc_len > 0)
    4525           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4526             :                 else
    4527           0 :                     return lldb_private::PythonString("").release();
    4528             :         }
    4529           0 : SWIGINTERN PyObject *lldb_SBTypeMemberFunction___str__(lldb::SBTypeMemberFunction *self){
    4530           0 :                 lldb::SBStream description;
    4531           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4532           0 :                 const char *desc = description.GetData();
    4533           0 :                 size_t desc_len = description.GetSize();
    4534           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4535             :                     --desc_len;
    4536           0 :                 if (desc_len > 0)
    4537           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4538             :                 else
    4539           0 :                     return lldb_private::PythonString("").release();
    4540             :         }
    4541           0 : SWIGINTERN PyObject *lldb_SBType___str__(lldb::SBType *self){
    4542           0 :                 lldb::SBStream description;
    4543           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4544           0 :                 const char *desc = description.GetData();
    4545           0 :                 size_t desc_len = description.GetSize();
    4546           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4547             :                     --desc_len;
    4548           0 :                 if (desc_len > 0)
    4549           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4550             :                 else
    4551           0 :                     return lldb_private::PythonString("").release();
    4552             :         }
    4553           0 : SWIGINTERN PyObject *lldb_SBTypeCategory___str__(lldb::SBTypeCategory *self){
    4554           0 :                 lldb::SBStream description;
    4555           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4556           0 :                 const char *desc = description.GetData();
    4557           0 :                 size_t desc_len = description.GetSize();
    4558           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4559             :                     --desc_len;
    4560           0 :                 if (desc_len > 0)
    4561           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4562             :                 else
    4563           0 :                     return lldb_private::PythonString("").release();
    4564             :         }
    4565           0 : SWIGINTERN PyObject *lldb_SBTypeEnumMember___str__(lldb::SBTypeEnumMember *self){
    4566           0 :                 lldb::SBStream description;
    4567           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4568           0 :                 const char *desc = description.GetData();
    4569           0 :                 size_t desc_len = description.GetSize();
    4570           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4571             :                     --desc_len;
    4572           0 :                 if (desc_len > 0)
    4573           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4574             :                 else
    4575           0 :                     return lldb_private::PythonString("").release();
    4576             :         }
    4577           0 : SWIGINTERN PyObject *lldb_SBTypeFilter___str__(lldb::SBTypeFilter *self){
    4578           0 :                 lldb::SBStream description;
    4579           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4580           0 :                 const char *desc = description.GetData();
    4581           0 :                 size_t desc_len = description.GetSize();
    4582           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4583             :                     --desc_len;
    4584           0 :                 if (desc_len > 0)
    4585           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4586             :                 else
    4587           0 :                     return lldb_private::PythonString("").release();
    4588             :         }
    4589           0 : SWIGINTERN PyObject *lldb_SBTypeFormat___str__(lldb::SBTypeFormat *self){
    4590           0 :                 lldb::SBStream description;
    4591           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4592           0 :                 const char *desc = description.GetData();
    4593           0 :                 size_t desc_len = description.GetSize();
    4594           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4595             :                     --desc_len;
    4596           0 :                 if (desc_len > 0)
    4597           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4598             :                 else
    4599           0 :                     return lldb_private::PythonString("").release();
    4600             :         }
    4601           0 : SWIGINTERN PyObject *lldb_SBTypeNameSpecifier___str__(lldb::SBTypeNameSpecifier *self){
    4602           0 :                 lldb::SBStream description;
    4603           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4604           0 :                 const char *desc = description.GetData();
    4605           0 :                 size_t desc_len = description.GetSize();
    4606           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4607             :                     --desc_len;
    4608           0 :                 if (desc_len > 0)
    4609           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4610             :                 else
    4611           0 :                     return lldb_private::PythonString("").release();
    4612             :         }
    4613           0 : SWIGINTERN PyObject *lldb_SBTypeSummary___str__(lldb::SBTypeSummary *self){
    4614           0 :                 lldb::SBStream description;
    4615           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4616           0 :                 const char *desc = description.GetData();
    4617           0 :                 size_t desc_len = description.GetSize();
    4618           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4619             :                     --desc_len;
    4620           0 :                 if (desc_len > 0)
    4621           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4622             :                 else
    4623           0 :                     return lldb_private::PythonString("").release();
    4624             :         }
    4625           0 : SWIGINTERN PyObject *lldb_SBTypeSynthetic___str__(lldb::SBTypeSynthetic *self){
    4626           0 :                 lldb::SBStream description;
    4627           0 :                 self->GetDescription (description, lldb::eDescriptionLevelBrief);
    4628           0 :                 const char *desc = description.GetData();
    4629           0 :                 size_t desc_len = description.GetSize();
    4630           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4631             :                     --desc_len;
    4632           0 :                 if (desc_len > 0)
    4633           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4634             :                 else
    4635           0 :                     return lldb_private::PythonString("").release();
    4636             :         }
    4637           1 : SWIGINTERN PyObject *lldb_SBValue___str__(lldb::SBValue *self){
    4638           2 :                 lldb::SBStream description;
    4639           1 :                 self->GetDescription (description);
    4640           1 :                 const char *desc = description.GetData();
    4641           1 :                 size_t desc_len = description.GetSize();
    4642           1 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4643             :                     --desc_len;
    4644           1 :                 if (desc_len > 0)
    4645           1 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4646             :                 else
    4647           0 :                     return lldb_private::PythonString("").release();
    4648             :         }
    4649           0 : SWIGINTERN PyObject *lldb_SBValueList___str__(lldb::SBValueList *self){
    4650           0 :                 lldb::SBStream description;
    4651           0 :                 const size_t n = self->GetSize();
    4652           0 :                 if (n)
    4653             :                 {
    4654           0 :                     for (size_t i=0; i<n; ++i)
    4655           0 :                         self->GetValueAtIndex(i).GetDescription(description);
    4656             :                 }
    4657             :                 else
    4658             :                 {
    4659           0 :                     description.Printf("<empty> lldb.SBValueList()");
    4660             :                 }
    4661           0 :                 const char *desc = description.GetData();
    4662           0 :                 size_t desc_len = description.GetSize();
    4663           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4664             :                     --desc_len;
    4665           0 :                 if (desc_len > 0)
    4666           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4667             :                 else
    4668           0 :                     return lldb_private::PythonString("").release();
    4669             :         }
    4670           0 : SWIGINTERN PyObject *lldb_SBWatchpoint___str__(lldb::SBWatchpoint *self){
    4671           0 :                 lldb::SBStream description;
    4672           0 :                 self->GetDescription (description, lldb::eDescriptionLevelVerbose);
    4673           0 :                 const char *desc = description.GetData();
    4674           0 :                 size_t desc_len = description.GetSize();
    4675           0 :                 if (desc_len > 0 && (desc[desc_len-1] == '\n' || desc[desc_len-1] == '\r'))
    4676             :                     --desc_len;
    4677           0 :                 if (desc_len > 0)
    4678           0 :                     return lldb_private::PythonString(llvm::StringRef(desc, desc_len)).release();
    4679             :                 else
    4680           0 :                     return lldb_private::PythonString("").release();
    4681             :         }
    4682             : 
    4683             : 
    4684             : template <typename T>
    4685             : PyObject *
    4686             : SBTypeToSWIGWrapper (T* item);
    4687             : 
    4688             : class PyErr_Cleaner
    4689             : {
    4690             : public:
    4691         127 :     PyErr_Cleaner(bool print=false) :
    4692           0 :     m_print(print)
    4693             :     {
    4694             :     }
    4695             : 
    4696         127 :     ~PyErr_Cleaner()
    4697         127 :     {
    4698         127 :         if (PyErr_Occurred())
    4699             :         {
    4700           0 :             if(m_print && !PyErr_ExceptionMatches(PyExc_SystemExit))
    4701           0 :                 PyErr_Print();
    4702           0 :             PyErr_Clear();
    4703             :         }
    4704         127 :     }
    4705             : 
    4706             : private:
    4707             :     bool m_print;
    4708             : };
    4709             : 
    4710             : 
    4711             : #ifdef __cplusplus
    4712             : extern "C" {
    4713             : #endif
    4714           0 : SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4715             :   PyObject *resultobj = 0;
    4716             :   lldb::SBAddress *result = 0 ;
    4717             :   
    4718           0 :   if (!PyArg_ParseTuple(args,(char *)":new_SBAddress")) SWIG_fail;
    4719             :   {
    4720             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4721           0 :     result = (lldb::SBAddress *)new lldb::SBAddress();
    4722             :     SWIG_PYTHON_THREAD_END_ALLOW;
    4723             :   }
    4724           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
    4725           0 :   return resultobj;
    4726             : fail:
    4727           0 :   return NULL;
    4728             : }
    4729             : 
    4730             : 
    4731           0 : SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4732             :   PyObject *resultobj = 0;
    4733             :   lldb::SBAddress *arg1 = 0 ;
    4734           0 :   void *argp1 = 0 ;
    4735             :   int res1 = 0 ;
    4736           0 :   PyObject * obj0 = 0 ;
    4737             :   lldb::SBAddress *result = 0 ;
    4738             :   
    4739           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBAddress",&obj0)) SWIG_fail;
    4740           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    4741           0 :   if (!SWIG_IsOK(res1)) {
    4742           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBAddress const &""'"); 
    4743             :   }
    4744           0 :   if (!argp1) {
    4745           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBAddress const &""'"); 
    4746             :   }
    4747             :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    4748             :   {
    4749             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4750           0 :     result = (lldb::SBAddress *)new lldb::SBAddress((lldb::SBAddress const &)*arg1);
    4751             :     SWIG_PYTHON_THREAD_END_ALLOW;
    4752             :   }
    4753           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
    4754           0 :   return resultobj;
    4755             : fail:
    4756             :   return NULL;
    4757             : }
    4758             : 
    4759             : 
    4760           0 : SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4761             :   PyObject *resultobj = 0;
    4762           0 :   lldb::SBSection arg1 ;
    4763             :   lldb::addr_t arg2 ;
    4764             :   void *argp1 ;
    4765             :   int res1 = 0 ;
    4766             :   unsigned long long val2 ;
    4767             :   int ecode2 = 0 ;
    4768           0 :   PyObject * obj0 = 0 ;
    4769           0 :   PyObject * obj1 = 0 ;
    4770             :   lldb::SBAddress *result = 0 ;
    4771             :   
    4772           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:new_SBAddress",&obj0,&obj1)) SWIG_fail;
    4773             :   {
    4774           0 :     res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBSection,  0  | 0);
    4775           0 :     if (!SWIG_IsOK(res1)) {
    4776           0 :       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBSection""'"); 
    4777             :     }  
    4778           0 :     if (!argp1) {
    4779           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::SBSection""'");
    4780             :     } else {
    4781             :       lldb::SBSection * temp = reinterpret_cast< lldb::SBSection * >(argp1);
    4782           0 :       arg1 = *temp;
    4783           0 :       if (SWIG_IsNewObj(res1)) delete temp;
    4784             :     }
    4785             :   }
    4786           0 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    4787           0 :   if (!SWIG_IsOK(ecode2)) {
    4788           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
    4789             :   } 
    4790           0 :   arg2 = static_cast< lldb::addr_t >(val2);
    4791             :   {
    4792             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4793           0 :     result = (lldb::SBAddress *)new lldb::SBAddress(arg1,arg2);
    4794             :     SWIG_PYTHON_THREAD_END_ALLOW;
    4795             :   }
    4796           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
    4797           0 :   return resultobj;
    4798             : fail:
    4799             :   return NULL;
    4800             : }
    4801             : 
    4802             : 
    4803           0 : SWIGINTERN PyObject *_wrap_new_SBAddress__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4804             :   PyObject *resultobj = 0;
    4805             :   lldb::addr_t arg1 ;
    4806             :   lldb::SBTarget *arg2 = 0 ;
    4807             :   unsigned long long val1 ;
    4808             :   int ecode1 = 0 ;
    4809           0 :   void *argp2 = 0 ;
    4810             :   int res2 = 0 ;
    4811           0 :   PyObject * obj0 = 0 ;
    4812           0 :   PyObject * obj1 = 0 ;
    4813             :   lldb::SBAddress *result = 0 ;
    4814             :   
    4815           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:new_SBAddress",&obj0,&obj1)) SWIG_fail;
    4816           0 :   ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
    4817           0 :   if (!SWIG_IsOK(ecode1)) {
    4818           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBAddress" "', argument " "1"" of type '" "lldb::addr_t""'");
    4819             :   } 
    4820           0 :   arg1 = static_cast< lldb::addr_t >(val1);
    4821           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBTarget,  0 );
    4822           0 :   if (!SWIG_IsOK(res2)) {
    4823           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SBAddress" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
    4824             :   }
    4825           0 :   if (!argp2) {
    4826           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBAddress" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
    4827             :   }
    4828             :   arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
    4829             :   {
    4830             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4831           0 :     result = (lldb::SBAddress *)new lldb::SBAddress(arg1,*arg2);
    4832             :     SWIG_PYTHON_THREAD_END_ALLOW;
    4833             :   }
    4834           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NEW |  0 );
    4835           0 :   return resultobj;
    4836             : fail:
    4837             :   return NULL;
    4838             : }
    4839             : 
    4840             : 
    4841           6 : SWIGINTERN PyObject *_wrap_new_SBAddress(PyObject *self, PyObject *args) {
    4842             :   Py_ssize_t argc;
    4843           6 :   PyObject *argv[3] = {
    4844             :     0
    4845             :   };
    4846             :   Py_ssize_t ii;
    4847             :   
    4848           6 :   if (!PyTuple_Check(args)) SWIG_fail;
    4849           6 :   argc = args ? PyObject_Length(args) : 0;
    4850          12 :   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    4851           6 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    4852             :   }
    4853           6 :   if (argc == 0) {
    4854           3 :     return _wrap_new_SBAddress__SWIG_0(self, args);
    4855             :   }
    4856           3 :   if (argc == 1) {
    4857             :     int _v;
    4858           0 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBAddress, 0);
    4859           0 :     _v = SWIG_CheckState(res);
    4860             :     if (_v) {
    4861           0 :       return _wrap_new_SBAddress__SWIG_1(self, args);
    4862             :     }
    4863             :   }
    4864           3 :   if (argc == 2) {
    4865             :     int _v;
    4866           3 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBSection, 0);
    4867           3 :     _v = SWIG_CheckState(res);
    4868             :     if (_v) {
    4869             :       {
    4870           2 :         int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
    4871           2 :         _v = SWIG_CheckState(res);
    4872             :       }
    4873             :       if (_v) {
    4874           2 :         return _wrap_new_SBAddress__SWIG_2(self, args);
    4875             :       }
    4876             :     }
    4877             :   }
    4878           1 :   if (argc == 2) {
    4879             :     int _v;
    4880             :     {
    4881           1 :       int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
    4882           1 :       _v = SWIG_CheckState(res);
    4883             :     }
    4884             :     if (_v) {
    4885           1 :       void *vptr = 0;
    4886           1 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    4887           1 :       _v = SWIG_CheckState(res);
    4888             :       if (_v) {
    4889           1 :         return _wrap_new_SBAddress__SWIG_3(self, args);
    4890             :       }
    4891             :     }
    4892             :   }
    4893             :   
    4894           0 : fail:
    4895           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SBAddress'.\n"
    4896             :     "  Possible C/C++ prototypes are:\n"
    4897             :     "    lldb::SBAddress::SBAddress()\n"
    4898             :     "    lldb::SBAddress::SBAddress(lldb::SBAddress const &)\n"
    4899             :     "    lldb::SBAddress::SBAddress(lldb::SBSection,lldb::addr_t)\n"
    4900             :     "    lldb::SBAddress::SBAddress(lldb::addr_t,lldb::SBTarget &)\n");
    4901           0 :   return 0;
    4902             : }
    4903             : 
    4904             : 
    4905       39350 : SWIGINTERN PyObject *_wrap_delete_SBAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4906             :   PyObject *resultobj = 0;
    4907             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    4908       39350 :   void *argp1 = 0 ;
    4909             :   int res1 = 0 ;
    4910       39350 :   PyObject * obj0 = 0 ;
    4911             :   
    4912       39350 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBAddress",&obj0)) SWIG_fail;
    4913       39350 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_DISOWN |  0 );
    4914       39350 :   if (!SWIG_IsOK(res1)) {
    4915           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    4916             :   }
    4917       39350 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    4918             :   {
    4919             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4920       39350 :     delete arg1;
    4921             :     SWIG_PYTHON_THREAD_END_ALLOW;
    4922             :   }
    4923             :   resultobj = SWIG_Py_Void();
    4924       39350 :   return resultobj;
    4925             : fail:
    4926             :   return NULL;
    4927             : }
    4928             : 
    4929             : 
    4930          10 : SWIGINTERN PyObject *_wrap_SBAddress_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4931             :   PyObject *resultobj = 0;
    4932             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    4933          10 :   void *argp1 = 0 ;
    4934             :   int res1 = 0 ;
    4935          10 :   PyObject * obj0 = 0 ;
    4936             :   bool result;
    4937             :   
    4938          10 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_IsValid",&obj0)) SWIG_fail;
    4939          10 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    4940          10 :   if (!SWIG_IsOK(res1)) {
    4941           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_IsValid" "', argument " "1"" of type '" "lldb::SBAddress const *""'"); 
    4942             :   }
    4943          10 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    4944             :   {
    4945             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4946          10 :     result = (bool)((lldb::SBAddress const *)arg1)->IsValid();
    4947             :     SWIG_PYTHON_THREAD_END_ALLOW;
    4948             :   }
    4949             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    4950          10 :   return resultobj;
    4951             : fail:
    4952             :   return NULL;
    4953             : }
    4954             : 
    4955             : 
    4956           3 : SWIGINTERN PyObject *_wrap_SBAddress_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4957             :   PyObject *resultobj = 0;
    4958             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    4959           3 :   void *argp1 = 0 ;
    4960             :   int res1 = 0 ;
    4961           3 :   PyObject * obj0 = 0 ;
    4962             :   
    4963           3 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_Clear",&obj0)) SWIG_fail;
    4964           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    4965           3 :   if (!SWIG_IsOK(res1)) {
    4966           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_Clear" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    4967             :   }
    4968           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    4969             :   {
    4970             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4971           3 :     (arg1)->Clear();
    4972             :     SWIG_PYTHON_THREAD_END_ALLOW;
    4973             :   }
    4974             :   resultobj = SWIG_Py_Void();
    4975           3 :   return resultobj;
    4976             : fail:
    4977             :   return NULL;
    4978             : }
    4979             : 
    4980             : 
    4981       39207 : SWIGINTERN PyObject *_wrap_SBAddress_GetFileAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    4982             :   PyObject *resultobj = 0;
    4983             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    4984       39207 :   void *argp1 = 0 ;
    4985             :   int res1 = 0 ;
    4986       39207 :   PyObject * obj0 = 0 ;
    4987             :   lldb::addr_t result;
    4988             :   
    4989       39207 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetFileAddress",&obj0)) SWIG_fail;
    4990       39207 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    4991       39207 :   if (!SWIG_IsOK(res1)) {
    4992           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetFileAddress" "', argument " "1"" of type '" "lldb::SBAddress const *""'"); 
    4993             :   }
    4994       39207 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    4995             :   {
    4996             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    4997       39207 :     result = (lldb::addr_t)((lldb::SBAddress const *)arg1)->GetFileAddress();
    4998             :     SWIG_PYTHON_THREAD_END_ALLOW;
    4999             :   }
    5000       39207 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    5001       39207 :   return resultobj;
    5002             : fail:
    5003             :   return NULL;
    5004             : }
    5005             : 
    5006             : 
    5007          30 : SWIGINTERN PyObject *_wrap_SBAddress_GetLoadAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5008             :   PyObject *resultobj = 0;
    5009             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5010             :   lldb::SBTarget *arg2 = 0 ;
    5011          30 :   void *argp1 = 0 ;
    5012             :   int res1 = 0 ;
    5013          30 :   void *argp2 = 0 ;
    5014             :   int res2 = 0 ;
    5015          30 :   PyObject * obj0 = 0 ;
    5016          30 :   PyObject * obj1 = 0 ;
    5017             :   lldb::addr_t result;
    5018             :   
    5019          30 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAddress_GetLoadAddress",&obj0,&obj1)) SWIG_fail;
    5020          30 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5021          30 :   if (!SWIG_IsOK(res1)) {
    5022           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetLoadAddress" "', argument " "1"" of type '" "lldb::SBAddress const *""'"); 
    5023             :   }
    5024          30 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5025          30 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBTarget,  0  | 0);
    5026          30 :   if (!SWIG_IsOK(res2)) {
    5027           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddress_GetLoadAddress" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
    5028             :   }
    5029          30 :   if (!argp2) {
    5030           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAddress_GetLoadAddress" "', argument " "2"" of type '" "lldb::SBTarget const &""'"); 
    5031             :   }
    5032             :   arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
    5033             :   {
    5034             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5035          30 :     result = (lldb::addr_t)((lldb::SBAddress const *)arg1)->GetLoadAddress((lldb::SBTarget const &)*arg2);
    5036             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5037             :   }
    5038          30 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    5039          30 :   return resultobj;
    5040             : fail:
    5041             :   return NULL;
    5042             : }
    5043             : 
    5044             : 
    5045           3 : SWIGINTERN PyObject *_wrap_SBAddress_SetLoadAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5046             :   PyObject *resultobj = 0;
    5047             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5048             :   lldb::addr_t arg2 ;
    5049             :   lldb::SBTarget *arg3 = 0 ;
    5050           3 :   void *argp1 = 0 ;
    5051             :   int res1 = 0 ;
    5052             :   unsigned long long val2 ;
    5053             :   int ecode2 = 0 ;
    5054           3 :   void *argp3 = 0 ;
    5055             :   int res3 = 0 ;
    5056           3 :   PyObject * obj0 = 0 ;
    5057           3 :   PyObject * obj1 = 0 ;
    5058           3 :   PyObject * obj2 = 0 ;
    5059             :   
    5060           3 :   if (!PyArg_ParseTuple(args,(char *)"OOO:SBAddress_SetLoadAddress",&obj0,&obj1,&obj2)) SWIG_fail;
    5061           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5062           3 :   if (!SWIG_IsOK(res1)) {
    5063           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_SetLoadAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5064             :   }
    5065           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5066           3 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    5067           3 :   if (!SWIG_IsOK(ecode2)) {
    5068           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAddress_SetLoadAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
    5069             :   } 
    5070           3 :   arg2 = static_cast< lldb::addr_t >(val2);
    5071           3 :   res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_lldb__SBTarget,  0 );
    5072           3 :   if (!SWIG_IsOK(res3)) {
    5073           0 :     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SBAddress_SetLoadAddress" "', argument " "3"" of type '" "lldb::SBTarget &""'"); 
    5074             :   }
    5075           3 :   if (!argp3) {
    5076           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAddress_SetLoadAddress" "', argument " "3"" of type '" "lldb::SBTarget &""'"); 
    5077             :   }
    5078             :   arg3 = reinterpret_cast< lldb::SBTarget * >(argp3);
    5079             :   {
    5080             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5081           3 :     (arg1)->SetLoadAddress(arg2,*arg3);
    5082             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5083             :   }
    5084             :   resultobj = SWIG_Py_Void();
    5085           3 :   return resultobj;
    5086             : fail:
    5087             :   return NULL;
    5088             : }
    5089             : 
    5090             : 
    5091           3 : SWIGINTERN PyObject *_wrap_SBAddress_OffsetAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5092             :   PyObject *resultobj = 0;
    5093             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5094             :   lldb::addr_t arg2 ;
    5095           3 :   void *argp1 = 0 ;
    5096             :   int res1 = 0 ;
    5097             :   unsigned long long val2 ;
    5098             :   int ecode2 = 0 ;
    5099           3 :   PyObject * obj0 = 0 ;
    5100           3 :   PyObject * obj1 = 0 ;
    5101             :   bool result;
    5102             :   
    5103           3 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAddress_OffsetAddress",&obj0,&obj1)) SWIG_fail;
    5104           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5105           3 :   if (!SWIG_IsOK(res1)) {
    5106           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_OffsetAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5107             :   }
    5108           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5109           3 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    5110           3 :   if (!SWIG_IsOK(ecode2)) {
    5111           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAddress_OffsetAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
    5112             :   } 
    5113           3 :   arg2 = static_cast< lldb::addr_t >(val2);
    5114             :   {
    5115             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5116           3 :     result = (bool)(arg1)->OffsetAddress(arg2);
    5117             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5118             :   }
    5119             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    5120           3 :   return resultobj;
    5121             : fail:
    5122             :   return NULL;
    5123             : }
    5124             : 
    5125             : 
    5126           3 : SWIGINTERN PyObject *_wrap_SBAddress_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5127             :   PyObject *resultobj = 0;
    5128             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5129             :   lldb::SBStream *arg2 = 0 ;
    5130           3 :   void *argp1 = 0 ;
    5131             :   int res1 = 0 ;
    5132           3 :   void *argp2 = 0 ;
    5133             :   int res2 = 0 ;
    5134           3 :   PyObject * obj0 = 0 ;
    5135           3 :   PyObject * obj1 = 0 ;
    5136             :   bool result;
    5137             :   
    5138           3 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAddress_GetDescription",&obj0,&obj1)) SWIG_fail;
    5139           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5140           3 :   if (!SWIG_IsOK(res1)) {
    5141           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetDescription" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5142             :   }
    5143           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5144           3 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
    5145           3 :   if (!SWIG_IsOK(res2)) {
    5146           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddress_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    5147             :   }
    5148           3 :   if (!argp2) {
    5149           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAddress_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    5150             :   }
    5151             :   arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
    5152             :   {
    5153             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5154           3 :     result = (bool)(arg1)->GetDescription(*arg2);
    5155             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5156             :   }
    5157             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    5158           3 :   return resultobj;
    5159             : fail:
    5160             :   return NULL;
    5161             : }
    5162             : 
    5163             : 
    5164           6 : SWIGINTERN PyObject *_wrap_SBAddress_GetSection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5165             :   PyObject *resultobj = 0;
    5166             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5167           6 :   void *argp1 = 0 ;
    5168             :   int res1 = 0 ;
    5169           6 :   PyObject * obj0 = 0 ;
    5170          12 :   lldb::SBSection result;
    5171             :   
    5172           6 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetSection",&obj0)) SWIG_fail;
    5173           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5174           6 :   if (!SWIG_IsOK(res1)) {
    5175           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetSection" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5176             :   }
    5177           6 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5178             :   {
    5179             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5180           6 :     result = (arg1)->GetSection();
    5181             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5182             :   }
    5183           6 :   resultobj = SWIG_NewPointerObj((new lldb::SBSection(static_cast< const lldb::SBSection& >(result))), SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_OWN |  0 );
    5184           6 :   return resultobj;
    5185             : fail:
    5186             :   return NULL;
    5187             : }
    5188             : 
    5189             : 
    5190           0 : SWIGINTERN PyObject *_wrap_SBAddress_GetOffset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5191             :   PyObject *resultobj = 0;
    5192             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5193           0 :   void *argp1 = 0 ;
    5194             :   int res1 = 0 ;
    5195           0 :   PyObject * obj0 = 0 ;
    5196             :   lldb::addr_t result;
    5197             :   
    5198           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetOffset",&obj0)) SWIG_fail;
    5199           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5200           0 :   if (!SWIG_IsOK(res1)) {
    5201           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetOffset" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5202             :   }
    5203           0 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5204             :   {
    5205             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5206           0 :     result = (lldb::addr_t)(arg1)->GetOffset();
    5207             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5208             :   }
    5209           0 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    5210           0 :   return resultobj;
    5211             : fail:
    5212             :   return NULL;
    5213             : }
    5214             : 
    5215             : 
    5216           0 : SWIGINTERN PyObject *_wrap_SBAddress_SetAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5217             :   PyObject *resultobj = 0;
    5218             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5219           0 :   lldb::SBSection arg2 ;
    5220             :   lldb::addr_t arg3 ;
    5221           0 :   void *argp1 = 0 ;
    5222             :   int res1 = 0 ;
    5223             :   void *argp2 ;
    5224             :   int res2 = 0 ;
    5225             :   unsigned long long val3 ;
    5226             :   int ecode3 = 0 ;
    5227           0 :   PyObject * obj0 = 0 ;
    5228           0 :   PyObject * obj1 = 0 ;
    5229           0 :   PyObject * obj2 = 0 ;
    5230             :   
    5231           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:SBAddress_SetAddress",&obj0,&obj1,&obj2)) SWIG_fail;
    5232           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5233           0 :   if (!SWIG_IsOK(res1)) {
    5234           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_SetAddress" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5235             :   }
    5236           0 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5237             :   {
    5238           0 :     res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBSection,  0  | 0);
    5239           0 :     if (!SWIG_IsOK(res2)) {
    5240           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAddress_SetAddress" "', argument " "2"" of type '" "lldb::SBSection""'"); 
    5241             :     }  
    5242           0 :     if (!argp2) {
    5243           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAddress_SetAddress" "', argument " "2"" of type '" "lldb::SBSection""'");
    5244             :     } else {
    5245             :       lldb::SBSection * temp = reinterpret_cast< lldb::SBSection * >(argp2);
    5246           0 :       arg2 = *temp;
    5247           0 :       if (SWIG_IsNewObj(res2)) delete temp;
    5248             :     }
    5249             :   }
    5250           0 :   ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(obj2, &val3);
    5251           0 :   if (!SWIG_IsOK(ecode3)) {
    5252           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBAddress_SetAddress" "', argument " "3"" of type '" "lldb::addr_t""'");
    5253             :   } 
    5254           0 :   arg3 = static_cast< lldb::addr_t >(val3);
    5255             :   {
    5256             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5257           0 :     (arg1)->SetAddress(arg2,arg3);
    5258             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5259             :   }
    5260             :   resultobj = SWIG_Py_Void();
    5261           0 :   return resultobj;
    5262             : fail:
    5263             :   return NULL;
    5264             : }
    5265             : 
    5266             : 
    5267           5 : SWIGINTERN PyObject *_wrap_SBAddress_GetSymbolContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5268             :   PyObject *resultobj = 0;
    5269             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5270             :   uint32_t arg2 ;
    5271           5 :   void *argp1 = 0 ;
    5272             :   int res1 = 0 ;
    5273             :   unsigned int val2 ;
    5274             :   int ecode2 = 0 ;
    5275           5 :   PyObject * obj0 = 0 ;
    5276           5 :   PyObject * obj1 = 0 ;
    5277          10 :   lldb::SBSymbolContext result;
    5278             :   
    5279           5 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAddress_GetSymbolContext",&obj0,&obj1)) SWIG_fail;
    5280           5 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5281           5 :   if (!SWIG_IsOK(res1)) {
    5282           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetSymbolContext" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5283             :   }
    5284           5 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5285           5 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    5286           5 :   if (!SWIG_IsOK(ecode2)) {
    5287           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAddress_GetSymbolContext" "', argument " "2"" of type '" "uint32_t""'");
    5288             :   } 
    5289             :   arg2 = static_cast< uint32_t >(val2);
    5290             :   {
    5291             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5292           5 :     result = (arg1)->GetSymbolContext(arg2);
    5293             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5294             :   }
    5295           5 :   resultobj = SWIG_NewPointerObj((new lldb::SBSymbolContext(static_cast< const lldb::SBSymbolContext& >(result))), SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_OWN |  0 );
    5296           5 :   return resultobj;
    5297             : fail:
    5298             :   return NULL;
    5299             : }
    5300             : 
    5301             : 
    5302           3 : SWIGINTERN PyObject *_wrap_SBAddress_GetModule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5303             :   PyObject *resultobj = 0;
    5304             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5305           3 :   void *argp1 = 0 ;
    5306             :   int res1 = 0 ;
    5307           3 :   PyObject * obj0 = 0 ;
    5308           6 :   lldb::SBModule result;
    5309             :   
    5310           3 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetModule",&obj0)) SWIG_fail;
    5311           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5312           3 :   if (!SWIG_IsOK(res1)) {
    5313           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetModule" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5314             :   }
    5315           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5316             :   {
    5317             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5318           3 :     result = (arg1)->GetModule();
    5319             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5320             :   }
    5321           3 :   resultobj = SWIG_NewPointerObj((new lldb::SBModule(static_cast< const lldb::SBModule& >(result))), SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_OWN |  0 );
    5322           3 :   return resultobj;
    5323             : fail:
    5324             :   return NULL;
    5325             : }
    5326             : 
    5327             : 
    5328          11 : SWIGINTERN PyObject *_wrap_SBAddress_GetCompileUnit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5329             :   PyObject *resultobj = 0;
    5330             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5331          11 :   void *argp1 = 0 ;
    5332             :   int res1 = 0 ;
    5333          11 :   PyObject * obj0 = 0 ;
    5334          22 :   lldb::SBCompileUnit result;
    5335             :   
    5336          11 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetCompileUnit",&obj0)) SWIG_fail;
    5337          11 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5338          11 :   if (!SWIG_IsOK(res1)) {
    5339           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetCompileUnit" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5340             :   }
    5341          11 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5342             :   {
    5343             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5344          11 :     result = (arg1)->GetCompileUnit();
    5345             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5346             :   }
    5347          11 :   resultobj = SWIG_NewPointerObj((new lldb::SBCompileUnit(static_cast< const lldb::SBCompileUnit& >(result))), SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_OWN |  0 );
    5348          11 :   return resultobj;
    5349             : fail:
    5350             :   return NULL;
    5351             : }
    5352             : 
    5353             : 
    5354          75 : SWIGINTERN PyObject *_wrap_SBAddress_GetFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5355             :   PyObject *resultobj = 0;
    5356             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5357          75 :   void *argp1 = 0 ;
    5358             :   int res1 = 0 ;
    5359          75 :   PyObject * obj0 = 0 ;
    5360         150 :   lldb::SBFunction result;
    5361             :   
    5362          75 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetFunction",&obj0)) SWIG_fail;
    5363          75 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5364          75 :   if (!SWIG_IsOK(res1)) {
    5365           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetFunction" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5366             :   }
    5367          75 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5368             :   {
    5369             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5370          75 :     result = (arg1)->GetFunction();
    5371             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5372             :   }
    5373          75 :   resultobj = SWIG_NewPointerObj((new lldb::SBFunction(static_cast< const lldb::SBFunction& >(result))), SWIGTYPE_p_lldb__SBFunction, SWIG_POINTER_OWN |  0 );
    5374          75 :   return resultobj;
    5375             : fail:
    5376             :   return NULL;
    5377             : }
    5378             : 
    5379             : 
    5380           3 : SWIGINTERN PyObject *_wrap_SBAddress_GetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5381             :   PyObject *resultobj = 0;
    5382             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5383           3 :   void *argp1 = 0 ;
    5384             :   int res1 = 0 ;
    5385           3 :   PyObject * obj0 = 0 ;
    5386           6 :   lldb::SBBlock result;
    5387             :   
    5388           3 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetBlock",&obj0)) SWIG_fail;
    5389           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5390           3 :   if (!SWIG_IsOK(res1)) {
    5391           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetBlock" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5392             :   }
    5393           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5394             :   {
    5395             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5396           3 :     result = (arg1)->GetBlock();
    5397             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5398             :   }
    5399           3 :   resultobj = SWIG_NewPointerObj((new lldb::SBBlock(static_cast< const lldb::SBBlock& >(result))), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
    5400           3 :   return resultobj;
    5401             : fail:
    5402             :   return NULL;
    5403             : }
    5404             : 
    5405             : 
    5406           3 : SWIGINTERN PyObject *_wrap_SBAddress_GetSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5407             :   PyObject *resultobj = 0;
    5408             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5409           3 :   void *argp1 = 0 ;
    5410             :   int res1 = 0 ;
    5411           3 :   PyObject * obj0 = 0 ;
    5412           6 :   lldb::SBSymbol result;
    5413             :   
    5414           3 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetSymbol",&obj0)) SWIG_fail;
    5415           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5416           3 :   if (!SWIG_IsOK(res1)) {
    5417           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetSymbol" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5418             :   }
    5419           3 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5420             :   {
    5421             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5422           3 :     result = (arg1)->GetSymbol();
    5423             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5424             :   }
    5425           3 :   resultobj = SWIG_NewPointerObj((new lldb::SBSymbol(static_cast< const lldb::SBSymbol& >(result))), SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_OWN |  0 );
    5426           3 :   return resultobj;
    5427             : fail:
    5428             :   return NULL;
    5429             : }
    5430             : 
    5431             : 
    5432           5 : SWIGINTERN PyObject *_wrap_SBAddress_GetLineEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5433             :   PyObject *resultobj = 0;
    5434             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5435           5 :   void *argp1 = 0 ;
    5436             :   int res1 = 0 ;
    5437           5 :   PyObject * obj0 = 0 ;
    5438          10 :   lldb::SBLineEntry result;
    5439             :   
    5440           5 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress_GetLineEntry",&obj0)) SWIG_fail;
    5441           5 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5442           5 :   if (!SWIG_IsOK(res1)) {
    5443           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress_GetLineEntry" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5444             :   }
    5445           5 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5446             :   {
    5447             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5448           5 :     result = (arg1)->GetLineEntry();
    5449             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5450             :   }
    5451           5 :   resultobj = SWIG_NewPointerObj((new lldb::SBLineEntry(static_cast< const lldb::SBLineEntry& >(result))), SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_OWN |  0 );
    5452           5 :   return resultobj;
    5453             : fail:
    5454             :   return NULL;
    5455             : }
    5456             : 
    5457             : 
    5458           0 : SWIGINTERN PyObject *_wrap_SBAddress___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5459             :   PyObject *resultobj = 0;
    5460             :   lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ;
    5461           0 :   void *argp1 = 0 ;
    5462             :   int res1 = 0 ;
    5463           0 :   PyObject * obj0 = 0 ;
    5464             :   PyObject *result = 0 ;
    5465             :   
    5466           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAddress___str__",&obj0)) SWIG_fail;
    5467           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAddress, 0 |  0 );
    5468           0 :   if (!SWIG_IsOK(res1)) {
    5469           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAddress___str__" "', argument " "1"" of type '" "lldb::SBAddress *""'"); 
    5470             :   }
    5471           0 :   arg1 = reinterpret_cast< lldb::SBAddress * >(argp1);
    5472           0 :   result = (PyObject *)lldb_SBAddress___str__(arg1);
    5473             :   resultobj = result;
    5474           0 :   return resultobj;
    5475             : fail:
    5476             :   return NULL;
    5477             : }
    5478             : 
    5479             : 
    5480         652 : SWIGINTERN PyObject *SBAddress_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5481             :   PyObject *obj;
    5482         652 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    5483         652 :   SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBAddress, SWIG_NewClientData(obj));
    5484         652 :   return SWIG_Py_Void();
    5485             : }
    5486             : 
    5487           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5488             :   PyObject *resultobj = 0;
    5489             :   lldb::SBAttachInfo *result = 0 ;
    5490             :   
    5491           0 :   if (!PyArg_ParseTuple(args,(char *)":new_SBAttachInfo")) SWIG_fail;
    5492             :   {
    5493             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5494           0 :     result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo();
    5495             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5496             :   }
    5497           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
    5498           0 :   return resultobj;
    5499             : fail:
    5500           0 :   return NULL;
    5501             : }
    5502             : 
    5503             : 
    5504           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5505             :   PyObject *resultobj = 0;
    5506             :   lldb::pid_t arg1 ;
    5507             :   unsigned long long val1 ;
    5508             :   int ecode1 = 0 ;
    5509           0 :   PyObject * obj0 = 0 ;
    5510             :   lldb::SBAttachInfo *result = 0 ;
    5511             :   
    5512           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBAttachInfo",&obj0)) SWIG_fail;
    5513           0 :   ecode1 = SWIG_AsVal_unsigned_SS_long_SS_long(obj0, &val1);
    5514           0 :   if (!SWIG_IsOK(ecode1)) {
    5515           0 :     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "lldb::pid_t""'");
    5516             :   } 
    5517           0 :   arg1 = static_cast< lldb::pid_t >(val1);
    5518             :   {
    5519             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5520           0 :     result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo(arg1);
    5521             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5522             :   }
    5523           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
    5524           0 :   return resultobj;
    5525             : fail:
    5526             :   return NULL;
    5527             : }
    5528             : 
    5529             : 
    5530           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5531             :   PyObject *resultobj = 0;
    5532             :   char *arg1 = (char *) 0 ;
    5533             :   bool arg2 ;
    5534             :   int res1 ;
    5535           0 :   char *buf1 = 0 ;
    5536           0 :   int alloc1 = 0 ;
    5537             :   bool val2 ;
    5538             :   int ecode2 = 0 ;
    5539           0 :   PyObject * obj0 = 0 ;
    5540           0 :   PyObject * obj1 = 0 ;
    5541             :   lldb::SBAttachInfo *result = 0 ;
    5542             :   
    5543           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:new_SBAttachInfo",&obj0,&obj1)) SWIG_fail;
    5544           0 :   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
    5545           0 :   if (!SWIG_IsOK(res1)) {
    5546           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "char const *""'");
    5547             :   }
    5548           0 :   arg1 = reinterpret_cast< char * >(buf1);
    5549           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    5550             :   if (!SWIG_IsOK(ecode2)) {
    5551           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBAttachInfo" "', argument " "2"" of type '" "bool""'");
    5552             :   } 
    5553             :   arg2 = static_cast< bool >(val2);
    5554             :   {
    5555             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5556           0 :     result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((char const *)arg1,arg2);
    5557             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5558             :   }
    5559           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
    5560           0 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    5561             :   return resultobj;
    5562           0 : fail:
    5563           0 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    5564             :   return NULL;
    5565             : }
    5566             : 
    5567             : 
    5568           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5569             :   PyObject *resultobj = 0;
    5570             :   char *arg1 = (char *) 0 ;
    5571             :   bool arg2 ;
    5572             :   bool arg3 ;
    5573             :   int res1 ;
    5574           0 :   char *buf1 = 0 ;
    5575           0 :   int alloc1 = 0 ;
    5576             :   bool val2 ;
    5577             :   int ecode2 = 0 ;
    5578             :   bool val3 ;
    5579             :   int ecode3 = 0 ;
    5580           0 :   PyObject * obj0 = 0 ;
    5581           0 :   PyObject * obj1 = 0 ;
    5582           0 :   PyObject * obj2 = 0 ;
    5583             :   lldb::SBAttachInfo *result = 0 ;
    5584             :   
    5585           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:new_SBAttachInfo",&obj0,&obj1,&obj2)) SWIG_fail;
    5586           0 :   res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
    5587           0 :   if (!SWIG_IsOK(res1)) {
    5588           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "char const *""'");
    5589             :   }
    5590           0 :   arg1 = reinterpret_cast< char * >(buf1);
    5591           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    5592             :   if (!SWIG_IsOK(ecode2)) {
    5593           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SBAttachInfo" "', argument " "2"" of type '" "bool""'");
    5594             :   } 
    5595             :   arg2 = static_cast< bool >(val2);
    5596           0 :   ecode3 = SWIG_AsVal_bool(obj2, &val3);
    5597             :   if (!SWIG_IsOK(ecode3)) {
    5598           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SBAttachInfo" "', argument " "3"" of type '" "bool""'");
    5599             :   } 
    5600             :   arg3 = static_cast< bool >(val3);
    5601             :   {
    5602             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5603           0 :     result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((char const *)arg1,arg2,arg3);
    5604             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5605             :   }
    5606           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
    5607           0 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    5608             :   return resultobj;
    5609           0 : fail:
    5610           0 :   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    5611             :   return NULL;
    5612             : }
    5613             : 
    5614             : 
    5615           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo__SWIG_4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5616             :   PyObject *resultobj = 0;
    5617             :   lldb::SBAttachInfo *arg1 = 0 ;
    5618           0 :   void *argp1 = 0 ;
    5619             :   int res1 = 0 ;
    5620           0 :   PyObject * obj0 = 0 ;
    5621             :   lldb::SBAttachInfo *result = 0 ;
    5622             :   
    5623           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBAttachInfo",&obj0)) SWIG_fail;
    5624           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBAttachInfo,  0  | 0);
    5625           0 :   if (!SWIG_IsOK(res1)) {
    5626           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "lldb::SBAttachInfo const &""'"); 
    5627             :   }
    5628           0 :   if (!argp1) {
    5629           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBAttachInfo" "', argument " "1"" of type '" "lldb::SBAttachInfo const &""'"); 
    5630             :   }
    5631             :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5632             :   {
    5633             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5634           0 :     result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((lldb::SBAttachInfo const &)*arg1);
    5635             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5636             :   }
    5637           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NEW |  0 );
    5638           0 :   return resultobj;
    5639             : fail:
    5640             :   return NULL;
    5641             : }
    5642             : 
    5643             : 
    5644           0 : SWIGINTERN PyObject *_wrap_new_SBAttachInfo(PyObject *self, PyObject *args) {
    5645             :   Py_ssize_t argc;
    5646           0 :   PyObject *argv[4] = {
    5647             :     0
    5648             :   };
    5649             :   Py_ssize_t ii;
    5650             :   
    5651           0 :   if (!PyTuple_Check(args)) SWIG_fail;
    5652           0 :   argc = args ? PyObject_Length(args) : 0;
    5653           0 :   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    5654           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    5655             :   }
    5656           0 :   if (argc == 0) {
    5657           0 :     return _wrap_new_SBAttachInfo__SWIG_0(self, args);
    5658             :   }
    5659           0 :   if (argc == 1) {
    5660             :     int _v;
    5661           0 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    5662           0 :     _v = SWIG_CheckState(res);
    5663             :     if (_v) {
    5664           0 :       return _wrap_new_SBAttachInfo__SWIG_4(self, args);
    5665             :     }
    5666             :   }
    5667           0 :   if (argc == 1) {
    5668             :     int _v;
    5669             :     {
    5670           0 :       int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], NULL);
    5671           0 :       _v = SWIG_CheckState(res);
    5672             :     }
    5673             :     if (_v) {
    5674           0 :       return _wrap_new_SBAttachInfo__SWIG_1(self, args);
    5675             :     }
    5676             :   }
    5677           0 :   if (argc == 2) {
    5678             :     int _v;
    5679           0 :     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    5680           0 :     _v = SWIG_CheckState(res);
    5681             :     if (_v) {
    5682             :       {
    5683           0 :         int res = SWIG_AsVal_bool(argv[1], NULL);
    5684             :         _v = SWIG_CheckState(res);
    5685             :       }
    5686             :       if (_v) {
    5687           0 :         return _wrap_new_SBAttachInfo__SWIG_2(self, args);
    5688             :       }
    5689             :     }
    5690             :   }
    5691           0 :   if (argc == 3) {
    5692             :     int _v;
    5693           0 :     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    5694           0 :     _v = SWIG_CheckState(res);
    5695             :     if (_v) {
    5696             :       {
    5697           0 :         int res = SWIG_AsVal_bool(argv[1], NULL);
    5698             :         _v = SWIG_CheckState(res);
    5699             :       }
    5700             :       if (_v) {
    5701             :         {
    5702           0 :           int res = SWIG_AsVal_bool(argv[2], NULL);
    5703             :           _v = SWIG_CheckState(res);
    5704             :         }
    5705             :         if (_v) {
    5706           0 :           return _wrap_new_SBAttachInfo__SWIG_3(self, args);
    5707             :         }
    5708             :       }
    5709             :     }
    5710             :   }
    5711             :   
    5712           0 : fail:
    5713           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SBAttachInfo'.\n"
    5714             :     "  Possible C/C++ prototypes are:\n"
    5715             :     "    lldb::SBAttachInfo::SBAttachInfo()\n"
    5716             :     "    lldb::SBAttachInfo::SBAttachInfo(lldb::pid_t)\n"
    5717             :     "    lldb::SBAttachInfo::SBAttachInfo(char const *,bool)\n"
    5718             :     "    lldb::SBAttachInfo::SBAttachInfo(char const *,bool,bool)\n"
    5719             :     "    lldb::SBAttachInfo::SBAttachInfo(lldb::SBAttachInfo const &)\n");
    5720           0 :   return 0;
    5721             : }
    5722             : 
    5723             : 
    5724           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetProcessID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5725             :   PyObject *resultobj = 0;
    5726             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5727           0 :   void *argp1 = 0 ;
    5728             :   int res1 = 0 ;
    5729           0 :   PyObject * obj0 = 0 ;
    5730             :   lldb::pid_t result;
    5731             :   
    5732           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetProcessID",&obj0)) SWIG_fail;
    5733           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5734           0 :   if (!SWIG_IsOK(res1)) {
    5735           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5736             :   }
    5737           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5738             :   {
    5739             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5740           0 :     result = (lldb::pid_t)(arg1)->GetProcessID();
    5741             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5742             :   }
    5743           0 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    5744           0 :   return resultobj;
    5745             : fail:
    5746             :   return NULL;
    5747             : }
    5748             : 
    5749             : 
    5750           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetProcessID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5751             :   PyObject *resultobj = 0;
    5752             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5753             :   lldb::pid_t arg2 ;
    5754           0 :   void *argp1 = 0 ;
    5755             :   int res1 = 0 ;
    5756             :   unsigned long long val2 ;
    5757             :   int ecode2 = 0 ;
    5758           0 :   PyObject * obj0 = 0 ;
    5759           0 :   PyObject * obj1 = 0 ;
    5760             :   
    5761           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetProcessID",&obj0,&obj1)) SWIG_fail;
    5762           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5763           0 :   if (!SWIG_IsOK(res1)) {
    5764           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5765             :   }
    5766           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5767           0 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    5768           0 :   if (!SWIG_IsOK(ecode2)) {
    5769           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetProcessID" "', argument " "2"" of type '" "lldb::pid_t""'");
    5770             :   } 
    5771           0 :   arg2 = static_cast< lldb::pid_t >(val2);
    5772             :   {
    5773             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5774           0 :     (arg1)->SetProcessID(arg2);
    5775             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5776             :   }
    5777             :   resultobj = SWIG_Py_Void();
    5778           0 :   return resultobj;
    5779             : fail:
    5780             :   return NULL;
    5781             : }
    5782             : 
    5783             : 
    5784           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5785             :   PyObject *resultobj = 0;
    5786             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5787             :   char *arg2 = (char *) 0 ;
    5788           0 :   void *argp1 = 0 ;
    5789             :   int res1 = 0 ;
    5790             :   int res2 ;
    5791           0 :   char *buf2 = 0 ;
    5792           0 :   int alloc2 = 0 ;
    5793           0 :   PyObject * obj0 = 0 ;
    5794           0 :   PyObject * obj1 = 0 ;
    5795             :   
    5796           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetExecutable",&obj0,&obj1)) SWIG_fail;
    5797           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5798           0 :   if (!SWIG_IsOK(res1)) {
    5799           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetExecutable" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5800             :   }
    5801           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5802           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    5803           0 :   if (!SWIG_IsOK(res2)) {
    5804           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetExecutable" "', argument " "2"" of type '" "char const *""'");
    5805             :   }
    5806           0 :   arg2 = reinterpret_cast< char * >(buf2);
    5807             :   {
    5808             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5809           0 :     (arg1)->SetExecutable((char const *)arg2);
    5810             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5811             :   }
    5812             :   resultobj = SWIG_Py_Void();
    5813           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    5814             :   return resultobj;
    5815           0 : fail:
    5816           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    5817             :   return NULL;
    5818             : }
    5819             : 
    5820             : 
    5821           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5822             :   PyObject *resultobj = 0;
    5823             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5824           0 :   lldb::SBFileSpec arg2 ;
    5825           0 :   void *argp1 = 0 ;
    5826             :   int res1 = 0 ;
    5827             :   void *argp2 ;
    5828             :   int res2 = 0 ;
    5829           0 :   PyObject * obj0 = 0 ;
    5830           0 :   PyObject * obj1 = 0 ;
    5831             :   
    5832           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetExecutable",&obj0,&obj1)) SWIG_fail;
    5833           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5834           0 :   if (!SWIG_IsOK(res1)) {
    5835           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetExecutable" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5836             :   }
    5837           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5838             :   {
    5839           0 :     res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBFileSpec,  0  | 0);
    5840           0 :     if (!SWIG_IsOK(res2)) {
    5841           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetExecutable" "', argument " "2"" of type '" "lldb::SBFileSpec""'"); 
    5842             :     }  
    5843           0 :     if (!argp2) {
    5844           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAttachInfo_SetExecutable" "', argument " "2"" of type '" "lldb::SBFileSpec""'");
    5845             :     } else {
    5846             :       lldb::SBFileSpec * temp = reinterpret_cast< lldb::SBFileSpec * >(argp2);
    5847           0 :       arg2 = *temp;
    5848           0 :       if (SWIG_IsNewObj(res2)) delete temp;
    5849             :     }
    5850             :   }
    5851             :   {
    5852             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5853           0 :     (arg1)->SetExecutable(arg2);
    5854             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5855             :   }
    5856             :   resultobj = SWIG_Py_Void();
    5857           0 :   return resultobj;
    5858             : fail:
    5859             :   return NULL;
    5860             : }
    5861             : 
    5862             : 
    5863           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetExecutable(PyObject *self, PyObject *args) {
    5864             :   Py_ssize_t argc;
    5865           0 :   PyObject *argv[3] = {
    5866             :     0
    5867             :   };
    5868             :   Py_ssize_t ii;
    5869             :   
    5870           0 :   if (!PyTuple_Check(args)) SWIG_fail;
    5871           0 :   argc = args ? PyObject_Length(args) : 0;
    5872           0 :   for (ii = 0; (ii < 2) && (ii < argc); ii++) {
    5873           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    5874             :   }
    5875           0 :   if (argc == 2) {
    5876             :     int _v;
    5877           0 :     void *vptr = 0;
    5878           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    5879           0 :     _v = SWIG_CheckState(res);
    5880             :     if (_v) {
    5881           0 :       int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_lldb__SBFileSpec, 0);
    5882           0 :       _v = SWIG_CheckState(res);
    5883             :       if (_v) {
    5884           0 :         return _wrap_SBAttachInfo_SetExecutable__SWIG_1(self, args);
    5885             :       }
    5886             :     }
    5887             :   }
    5888           0 :   if (argc == 2) {
    5889             :     int _v;
    5890           0 :     void *vptr = 0;
    5891           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    5892           0 :     _v = SWIG_CheckState(res);
    5893             :     if (_v) {
    5894           0 :       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
    5895           0 :       _v = SWIG_CheckState(res);
    5896             :       if (_v) {
    5897           0 :         return _wrap_SBAttachInfo_SetExecutable__SWIG_0(self, args);
    5898             :       }
    5899             :     }
    5900             :   }
    5901             :   
    5902           0 : fail:
    5903           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SBAttachInfo_SetExecutable'.\n"
    5904             :     "  Possible C/C++ prototypes are:\n"
    5905             :     "    lldb::SBAttachInfo::SetExecutable(char const *)\n"
    5906             :     "    lldb::SBAttachInfo::SetExecutable(lldb::SBFileSpec)\n");
    5907           0 :   return 0;
    5908             : }
    5909             : 
    5910             : 
    5911           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetWaitForLaunch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5912             :   PyObject *resultobj = 0;
    5913             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5914           0 :   void *argp1 = 0 ;
    5915             :   int res1 = 0 ;
    5916           0 :   PyObject * obj0 = 0 ;
    5917             :   bool result;
    5918             :   
    5919           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetWaitForLaunch",&obj0)) SWIG_fail;
    5920           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5921           0 :   if (!SWIG_IsOK(res1)) {
    5922           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetWaitForLaunch" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5923             :   }
    5924           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5925             :   {
    5926             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5927           0 :     result = (bool)(arg1)->GetWaitForLaunch();
    5928             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5929             :   }
    5930             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    5931           0 :   return resultobj;
    5932             : fail:
    5933             :   return NULL;
    5934             : }
    5935             : 
    5936             : 
    5937           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5938             :   PyObject *resultobj = 0;
    5939             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5940             :   bool arg2 ;
    5941           0 :   void *argp1 = 0 ;
    5942             :   int res1 = 0 ;
    5943             :   bool val2 ;
    5944             :   int ecode2 = 0 ;
    5945           0 :   PyObject * obj0 = 0 ;
    5946           0 :   PyObject * obj1 = 0 ;
    5947             :   
    5948           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetWaitForLaunch",&obj0,&obj1)) SWIG_fail;
    5949           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5950           0 :   if (!SWIG_IsOK(res1)) {
    5951           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5952             :   }
    5953           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5954           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    5955             :   if (!SWIG_IsOK(ecode2)) {
    5956           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "2"" of type '" "bool""'");
    5957             :   } 
    5958             :   arg2 = static_cast< bool >(val2);
    5959             :   {
    5960             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    5961           0 :     (arg1)->SetWaitForLaunch(arg2);
    5962             :     SWIG_PYTHON_THREAD_END_ALLOW;
    5963             :   }
    5964             :   resultobj = SWIG_Py_Void();
    5965           0 :   return resultobj;
    5966             : fail:
    5967             :   return NULL;
    5968             : }
    5969             : 
    5970             : 
    5971           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    5972             :   PyObject *resultobj = 0;
    5973             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    5974             :   bool arg2 ;
    5975             :   bool arg3 ;
    5976           0 :   void *argp1 = 0 ;
    5977             :   int res1 = 0 ;
    5978             :   bool val2 ;
    5979             :   int ecode2 = 0 ;
    5980             :   bool val3 ;
    5981             :   int ecode3 = 0 ;
    5982           0 :   PyObject * obj0 = 0 ;
    5983           0 :   PyObject * obj1 = 0 ;
    5984           0 :   PyObject * obj2 = 0 ;
    5985             :   
    5986           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:SBAttachInfo_SetWaitForLaunch",&obj0,&obj1,&obj2)) SWIG_fail;
    5987           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    5988           0 :   if (!SWIG_IsOK(res1)) {
    5989           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    5990             :   }
    5991           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    5992           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    5993             :   if (!SWIG_IsOK(ecode2)) {
    5994           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "2"" of type '" "bool""'");
    5995             :   } 
    5996             :   arg2 = static_cast< bool >(val2);
    5997           0 :   ecode3 = SWIG_AsVal_bool(obj2, &val3);
    5998             :   if (!SWIG_IsOK(ecode3)) {
    5999           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBAttachInfo_SetWaitForLaunch" "', argument " "3"" of type '" "bool""'");
    6000             :   } 
    6001             :   arg3 = static_cast< bool >(val3);
    6002             :   {
    6003             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6004           0 :     (arg1)->SetWaitForLaunch(arg2,arg3);
    6005             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6006             :   }
    6007             :   resultobj = SWIG_Py_Void();
    6008           0 :   return resultobj;
    6009             : fail:
    6010             :   return NULL;
    6011             : }
    6012             : 
    6013             : 
    6014           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetWaitForLaunch(PyObject *self, PyObject *args) {
    6015             :   Py_ssize_t argc;
    6016           0 :   PyObject *argv[4] = {
    6017             :     0
    6018             :   };
    6019             :   Py_ssize_t ii;
    6020             :   
    6021           0 :   if (!PyTuple_Check(args)) SWIG_fail;
    6022           0 :   argc = args ? PyObject_Length(args) : 0;
    6023           0 :   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    6024           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    6025             :   }
    6026           0 :   if (argc == 2) {
    6027             :     int _v;
    6028           0 :     void *vptr = 0;
    6029           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    6030           0 :     _v = SWIG_CheckState(res);
    6031             :     if (_v) {
    6032             :       {
    6033           0 :         int res = SWIG_AsVal_bool(argv[1], NULL);
    6034             :         _v = SWIG_CheckState(res);
    6035             :       }
    6036             :       if (_v) {
    6037           0 :         return _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(self, args);
    6038             :       }
    6039             :     }
    6040             :   }
    6041           0 :   if (argc == 3) {
    6042             :     int _v;
    6043           0 :     void *vptr = 0;
    6044           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBAttachInfo, 0);
    6045           0 :     _v = SWIG_CheckState(res);
    6046             :     if (_v) {
    6047             :       {
    6048           0 :         int res = SWIG_AsVal_bool(argv[1], NULL);
    6049             :         _v = SWIG_CheckState(res);
    6050             :       }
    6051             :       if (_v) {
    6052             :         {
    6053           0 :           int res = SWIG_AsVal_bool(argv[2], NULL);
    6054             :           _v = SWIG_CheckState(res);
    6055             :         }
    6056             :         if (_v) {
    6057           0 :           return _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_1(self, args);
    6058             :         }
    6059             :       }
    6060             :     }
    6061             :   }
    6062             :   
    6063           0 : fail:
    6064           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SBAttachInfo_SetWaitForLaunch'.\n"
    6065             :     "  Possible C/C++ prototypes are:\n"
    6066             :     "    lldb::SBAttachInfo::SetWaitForLaunch(bool)\n"
    6067             :     "    lldb::SBAttachInfo::SetWaitForLaunch(bool,bool)\n");
    6068           0 :   return 0;
    6069             : }
    6070             : 
    6071             : 
    6072           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetIgnoreExisting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6073             :   PyObject *resultobj = 0;
    6074             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6075           0 :   void *argp1 = 0 ;
    6076             :   int res1 = 0 ;
    6077           0 :   PyObject * obj0 = 0 ;
    6078             :   bool result;
    6079             :   
    6080           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetIgnoreExisting",&obj0)) SWIG_fail;
    6081           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6082           0 :   if (!SWIG_IsOK(res1)) {
    6083           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetIgnoreExisting" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6084             :   }
    6085           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6086             :   {
    6087             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6088           0 :     result = (bool)(arg1)->GetIgnoreExisting();
    6089             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6090             :   }
    6091             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6092           0 :   return resultobj;
    6093             : fail:
    6094             :   return NULL;
    6095             : }
    6096             : 
    6097             : 
    6098           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetIgnoreExisting(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6099             :   PyObject *resultobj = 0;
    6100             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6101             :   bool arg2 ;
    6102           0 :   void *argp1 = 0 ;
    6103             :   int res1 = 0 ;
    6104             :   bool val2 ;
    6105             :   int ecode2 = 0 ;
    6106           0 :   PyObject * obj0 = 0 ;
    6107           0 :   PyObject * obj1 = 0 ;
    6108             :   
    6109           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetIgnoreExisting",&obj0,&obj1)) SWIG_fail;
    6110           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6111           0 :   if (!SWIG_IsOK(res1)) {
    6112           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetIgnoreExisting" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6113             :   }
    6114           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6115           0 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    6116             :   if (!SWIG_IsOK(ecode2)) {
    6117           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetIgnoreExisting" "', argument " "2"" of type '" "bool""'");
    6118             :   } 
    6119             :   arg2 = static_cast< bool >(val2);
    6120             :   {
    6121             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6122           0 :     (arg1)->SetIgnoreExisting(arg2);
    6123             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6124             :   }
    6125             :   resultobj = SWIG_Py_Void();
    6126           0 :   return resultobj;
    6127             : fail:
    6128             :   return NULL;
    6129             : }
    6130             : 
    6131             : 
    6132           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetResumeCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6133             :   PyObject *resultobj = 0;
    6134             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6135           0 :   void *argp1 = 0 ;
    6136             :   int res1 = 0 ;
    6137           0 :   PyObject * obj0 = 0 ;
    6138             :   uint32_t result;
    6139             :   
    6140           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetResumeCount",&obj0)) SWIG_fail;
    6141           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6142           0 :   if (!SWIG_IsOK(res1)) {
    6143           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetResumeCount" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6144             :   }
    6145           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6146             :   {
    6147             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6148           0 :     result = (uint32_t)(arg1)->GetResumeCount();
    6149             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6150             :   }
    6151             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    6152           0 :   return resultobj;
    6153             : fail:
    6154             :   return NULL;
    6155             : }
    6156             : 
    6157             : 
    6158           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetResumeCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6159             :   PyObject *resultobj = 0;
    6160             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6161             :   uint32_t arg2 ;
    6162           0 :   void *argp1 = 0 ;
    6163             :   int res1 = 0 ;
    6164             :   unsigned int val2 ;
    6165             :   int ecode2 = 0 ;
    6166           0 :   PyObject * obj0 = 0 ;
    6167           0 :   PyObject * obj1 = 0 ;
    6168             :   
    6169           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetResumeCount",&obj0,&obj1)) SWIG_fail;
    6170           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6171           0 :   if (!SWIG_IsOK(res1)) {
    6172           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetResumeCount" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6173             :   }
    6174           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6175           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    6176           0 :   if (!SWIG_IsOK(ecode2)) {
    6177           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetResumeCount" "', argument " "2"" of type '" "uint32_t""'");
    6178             :   } 
    6179             :   arg2 = static_cast< uint32_t >(val2);
    6180             :   {
    6181             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6182           0 :     (arg1)->SetResumeCount(arg2);
    6183             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6184             :   }
    6185             :   resultobj = SWIG_Py_Void();
    6186           0 :   return resultobj;
    6187             : fail:
    6188             :   return NULL;
    6189             : }
    6190             : 
    6191             : 
    6192           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetProcessPluginName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6193             :   PyObject *resultobj = 0;
    6194             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6195           0 :   void *argp1 = 0 ;
    6196             :   int res1 = 0 ;
    6197           0 :   PyObject * obj0 = 0 ;
    6198             :   char *result = 0 ;
    6199             :   
    6200           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetProcessPluginName",&obj0)) SWIG_fail;
    6201           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6202           0 :   if (!SWIG_IsOK(res1)) {
    6203           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetProcessPluginName" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6204             :   }
    6205           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6206             :   {
    6207             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6208           0 :     result = (char *)(arg1)->GetProcessPluginName();
    6209             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6210             :   }
    6211           0 :   resultobj = SWIG_FromCharPtr((const char *)result);
    6212           0 :   return resultobj;
    6213             : fail:
    6214             :   return NULL;
    6215             : }
    6216             : 
    6217             : 
    6218           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetProcessPluginName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6219             :   PyObject *resultobj = 0;
    6220             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6221             :   char *arg2 = (char *) 0 ;
    6222           0 :   void *argp1 = 0 ;
    6223             :   int res1 = 0 ;
    6224             :   int res2 ;
    6225           0 :   char *buf2 = 0 ;
    6226           0 :   int alloc2 = 0 ;
    6227           0 :   PyObject * obj0 = 0 ;
    6228           0 :   PyObject * obj1 = 0 ;
    6229             :   
    6230           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetProcessPluginName",&obj0,&obj1)) SWIG_fail;
    6231           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6232           0 :   if (!SWIG_IsOK(res1)) {
    6233           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetProcessPluginName" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6234             :   }
    6235           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6236           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    6237           0 :   if (!SWIG_IsOK(res2)) {
    6238           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetProcessPluginName" "', argument " "2"" of type '" "char const *""'");
    6239             :   }
    6240           0 :   arg2 = reinterpret_cast< char * >(buf2);
    6241             :   {
    6242             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6243           0 :     (arg1)->SetProcessPluginName((char const *)arg2);
    6244             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6245             :   }
    6246             :   resultobj = SWIG_Py_Void();
    6247           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    6248             :   return resultobj;
    6249           0 : fail:
    6250           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    6251             :   return NULL;
    6252             : }
    6253             : 
    6254             : 
    6255           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetUserID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6256             :   PyObject *resultobj = 0;
    6257             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6258           0 :   void *argp1 = 0 ;
    6259             :   int res1 = 0 ;
    6260           0 :   PyObject * obj0 = 0 ;
    6261             :   uint32_t result;
    6262             :   
    6263           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetUserID",&obj0)) SWIG_fail;
    6264           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6265           0 :   if (!SWIG_IsOK(res1)) {
    6266           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6267             :   }
    6268           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6269             :   {
    6270             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6271           0 :     result = (uint32_t)(arg1)->GetUserID();
    6272             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6273             :   }
    6274             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    6275           0 :   return resultobj;
    6276             : fail:
    6277             :   return NULL;
    6278             : }
    6279             : 
    6280             : 
    6281           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetGroupID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6282             :   PyObject *resultobj = 0;
    6283             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6284           0 :   void *argp1 = 0 ;
    6285             :   int res1 = 0 ;
    6286           0 :   PyObject * obj0 = 0 ;
    6287             :   uint32_t result;
    6288             :   
    6289           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetGroupID",&obj0)) SWIG_fail;
    6290           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6291           0 :   if (!SWIG_IsOK(res1)) {
    6292           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6293             :   }
    6294           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6295             :   {
    6296             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6297           0 :     result = (uint32_t)(arg1)->GetGroupID();
    6298             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6299             :   }
    6300             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    6301           0 :   return resultobj;
    6302             : fail:
    6303             :   return NULL;
    6304             : }
    6305             : 
    6306             : 
    6307           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_UserIDIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6308             :   PyObject *resultobj = 0;
    6309             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6310           0 :   void *argp1 = 0 ;
    6311             :   int res1 = 0 ;
    6312           0 :   PyObject * obj0 = 0 ;
    6313             :   bool result;
    6314             :   
    6315           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_UserIDIsValid",&obj0)) SWIG_fail;
    6316           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6317           0 :   if (!SWIG_IsOK(res1)) {
    6318           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_UserIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6319             :   }
    6320           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6321             :   {
    6322             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6323           0 :     result = (bool)(arg1)->UserIDIsValid();
    6324             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6325             :   }
    6326             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6327           0 :   return resultobj;
    6328             : fail:
    6329             :   return NULL;
    6330             : }
    6331             : 
    6332             : 
    6333           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GroupIDIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6334             :   PyObject *resultobj = 0;
    6335             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6336           0 :   void *argp1 = 0 ;
    6337             :   int res1 = 0 ;
    6338           0 :   PyObject * obj0 = 0 ;
    6339             :   bool result;
    6340             :   
    6341           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GroupIDIsValid",&obj0)) SWIG_fail;
    6342           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6343           0 :   if (!SWIG_IsOK(res1)) {
    6344           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GroupIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6345             :   }
    6346           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6347             :   {
    6348             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6349           0 :     result = (bool)(arg1)->GroupIDIsValid();
    6350             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6351             :   }
    6352             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6353           0 :   return resultobj;
    6354             : fail:
    6355             :   return NULL;
    6356             : }
    6357             : 
    6358             : 
    6359           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetUserID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6360             :   PyObject *resultobj = 0;
    6361             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6362             :   uint32_t arg2 ;
    6363           0 :   void *argp1 = 0 ;
    6364             :   int res1 = 0 ;
    6365             :   unsigned int val2 ;
    6366             :   int ecode2 = 0 ;
    6367           0 :   PyObject * obj0 = 0 ;
    6368           0 :   PyObject * obj1 = 0 ;
    6369             :   
    6370           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetUserID",&obj0,&obj1)) SWIG_fail;
    6371           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6372           0 :   if (!SWIG_IsOK(res1)) {
    6373           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6374             :   }
    6375           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6376           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    6377           0 :   if (!SWIG_IsOK(ecode2)) {
    6378           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetUserID" "', argument " "2"" of type '" "uint32_t""'");
    6379             :   } 
    6380             :   arg2 = static_cast< uint32_t >(val2);
    6381             :   {
    6382             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6383           0 :     (arg1)->SetUserID(arg2);
    6384             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6385             :   }
    6386             :   resultobj = SWIG_Py_Void();
    6387           0 :   return resultobj;
    6388             : fail:
    6389             :   return NULL;
    6390             : }
    6391             : 
    6392             : 
    6393           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetGroupID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6394             :   PyObject *resultobj = 0;
    6395             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6396             :   uint32_t arg2 ;
    6397           0 :   void *argp1 = 0 ;
    6398             :   int res1 = 0 ;
    6399             :   unsigned int val2 ;
    6400             :   int ecode2 = 0 ;
    6401           0 :   PyObject * obj0 = 0 ;
    6402           0 :   PyObject * obj1 = 0 ;
    6403             :   
    6404           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetGroupID",&obj0,&obj1)) SWIG_fail;
    6405           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6406           0 :   if (!SWIG_IsOK(res1)) {
    6407           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6408             :   }
    6409           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6410           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    6411           0 :   if (!SWIG_IsOK(ecode2)) {
    6412           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetGroupID" "', argument " "2"" of type '" "uint32_t""'");
    6413             :   } 
    6414             :   arg2 = static_cast< uint32_t >(val2);
    6415             :   {
    6416             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6417           0 :     (arg1)->SetGroupID(arg2);
    6418             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6419             :   }
    6420             :   resultobj = SWIG_Py_Void();
    6421           0 :   return resultobj;
    6422             : fail:
    6423             :   return NULL;
    6424             : }
    6425             : 
    6426             : 
    6427           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetEffectiveUserID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6428             :   PyObject *resultobj = 0;
    6429             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6430           0 :   void *argp1 = 0 ;
    6431             :   int res1 = 0 ;
    6432           0 :   PyObject * obj0 = 0 ;
    6433             :   uint32_t result;
    6434             :   
    6435           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetEffectiveUserID",&obj0)) SWIG_fail;
    6436           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6437           0 :   if (!SWIG_IsOK(res1)) {
    6438           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetEffectiveUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6439             :   }
    6440           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6441             :   {
    6442             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6443           0 :     result = (uint32_t)(arg1)->GetEffectiveUserID();
    6444             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6445             :   }
    6446             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    6447           0 :   return resultobj;
    6448             : fail:
    6449             :   return NULL;
    6450             : }
    6451             : 
    6452             : 
    6453           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetEffectiveGroupID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6454             :   PyObject *resultobj = 0;
    6455             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6456           0 :   void *argp1 = 0 ;
    6457             :   int res1 = 0 ;
    6458           0 :   PyObject * obj0 = 0 ;
    6459             :   uint32_t result;
    6460             :   
    6461           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetEffectiveGroupID",&obj0)) SWIG_fail;
    6462           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6463           0 :   if (!SWIG_IsOK(res1)) {
    6464           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetEffectiveGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6465             :   }
    6466           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6467             :   {
    6468             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6469           0 :     result = (uint32_t)(arg1)->GetEffectiveGroupID();
    6470             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6471             :   }
    6472             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    6473           0 :   return resultobj;
    6474             : fail:
    6475             :   return NULL;
    6476             : }
    6477             : 
    6478             : 
    6479           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_EffectiveUserIDIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6480             :   PyObject *resultobj = 0;
    6481             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6482           0 :   void *argp1 = 0 ;
    6483             :   int res1 = 0 ;
    6484           0 :   PyObject * obj0 = 0 ;
    6485             :   bool result;
    6486             :   
    6487           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_EffectiveUserIDIsValid",&obj0)) SWIG_fail;
    6488           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6489           0 :   if (!SWIG_IsOK(res1)) {
    6490           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_EffectiveUserIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6491             :   }
    6492           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6493             :   {
    6494             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6495           0 :     result = (bool)(arg1)->EffectiveUserIDIsValid();
    6496             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6497             :   }
    6498             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6499           0 :   return resultobj;
    6500             : fail:
    6501             :   return NULL;
    6502             : }
    6503             : 
    6504             : 
    6505           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_EffectiveGroupIDIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6506             :   PyObject *resultobj = 0;
    6507             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6508           0 :   void *argp1 = 0 ;
    6509             :   int res1 = 0 ;
    6510           0 :   PyObject * obj0 = 0 ;
    6511             :   bool result;
    6512             :   
    6513           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_EffectiveGroupIDIsValid",&obj0)) SWIG_fail;
    6514           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6515           0 :   if (!SWIG_IsOK(res1)) {
    6516           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_EffectiveGroupIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6517             :   }
    6518           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6519             :   {
    6520             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6521           0 :     result = (bool)(arg1)->EffectiveGroupIDIsValid();
    6522             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6523             :   }
    6524             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6525           0 :   return resultobj;
    6526             : fail:
    6527             :   return NULL;
    6528             : }
    6529             : 
    6530             : 
    6531           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetEffectiveUserID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6532             :   PyObject *resultobj = 0;
    6533             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6534             :   uint32_t arg2 ;
    6535           0 :   void *argp1 = 0 ;
    6536             :   int res1 = 0 ;
    6537             :   unsigned int val2 ;
    6538             :   int ecode2 = 0 ;
    6539           0 :   PyObject * obj0 = 0 ;
    6540           0 :   PyObject * obj1 = 0 ;
    6541             :   
    6542           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetEffectiveUserID",&obj0,&obj1)) SWIG_fail;
    6543           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6544           0 :   if (!SWIG_IsOK(res1)) {
    6545           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetEffectiveUserID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6546             :   }
    6547           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6548           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    6549           0 :   if (!SWIG_IsOK(ecode2)) {
    6550           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetEffectiveUserID" "', argument " "2"" of type '" "uint32_t""'");
    6551             :   } 
    6552             :   arg2 = static_cast< uint32_t >(val2);
    6553             :   {
    6554             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6555           0 :     (arg1)->SetEffectiveUserID(arg2);
    6556             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6557             :   }
    6558             :   resultobj = SWIG_Py_Void();
    6559           0 :   return resultobj;
    6560             : fail:
    6561             :   return NULL;
    6562             : }
    6563             : 
    6564             : 
    6565           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetEffectiveGroupID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6566             :   PyObject *resultobj = 0;
    6567             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6568             :   uint32_t arg2 ;
    6569           0 :   void *argp1 = 0 ;
    6570             :   int res1 = 0 ;
    6571             :   unsigned int val2 ;
    6572             :   int ecode2 = 0 ;
    6573           0 :   PyObject * obj0 = 0 ;
    6574           0 :   PyObject * obj1 = 0 ;
    6575             :   
    6576           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetEffectiveGroupID",&obj0,&obj1)) SWIG_fail;
    6577           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6578           0 :   if (!SWIG_IsOK(res1)) {
    6579           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetEffectiveGroupID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6580             :   }
    6581           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6582           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    6583           0 :   if (!SWIG_IsOK(ecode2)) {
    6584           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetEffectiveGroupID" "', argument " "2"" of type '" "uint32_t""'");
    6585             :   } 
    6586             :   arg2 = static_cast< uint32_t >(val2);
    6587             :   {
    6588             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6589           0 :     (arg1)->SetEffectiveGroupID(arg2);
    6590             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6591             :   }
    6592             :   resultobj = SWIG_Py_Void();
    6593           0 :   return resultobj;
    6594             : fail:
    6595             :   return NULL;
    6596             : }
    6597             : 
    6598             : 
    6599           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetParentProcessID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6600             :   PyObject *resultobj = 0;
    6601             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6602           0 :   void *argp1 = 0 ;
    6603             :   int res1 = 0 ;
    6604           0 :   PyObject * obj0 = 0 ;
    6605             :   lldb::pid_t result;
    6606             :   
    6607           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetParentProcessID",&obj0)) SWIG_fail;
    6608           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6609           0 :   if (!SWIG_IsOK(res1)) {
    6610           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetParentProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6611             :   }
    6612           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6613             :   {
    6614             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6615           0 :     result = (lldb::pid_t)(arg1)->GetParentProcessID();
    6616             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6617             :   }
    6618           0 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    6619           0 :   return resultobj;
    6620             : fail:
    6621             :   return NULL;
    6622             : }
    6623             : 
    6624             : 
    6625           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetParentProcessID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6626             :   PyObject *resultobj = 0;
    6627             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6628             :   lldb::pid_t arg2 ;
    6629           0 :   void *argp1 = 0 ;
    6630             :   int res1 = 0 ;
    6631             :   unsigned long long val2 ;
    6632             :   int ecode2 = 0 ;
    6633           0 :   PyObject * obj0 = 0 ;
    6634           0 :   PyObject * obj1 = 0 ;
    6635             :   
    6636           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetParentProcessID",&obj0,&obj1)) SWIG_fail;
    6637           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6638           0 :   if (!SWIG_IsOK(res1)) {
    6639           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetParentProcessID" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6640             :   }
    6641           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6642           0 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    6643           0 :   if (!SWIG_IsOK(ecode2)) {
    6644           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBAttachInfo_SetParentProcessID" "', argument " "2"" of type '" "lldb::pid_t""'");
    6645             :   } 
    6646           0 :   arg2 = static_cast< lldb::pid_t >(val2);
    6647             :   {
    6648             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6649           0 :     (arg1)->SetParentProcessID(arg2);
    6650             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6651             :   }
    6652             :   resultobj = SWIG_Py_Void();
    6653           0 :   return resultobj;
    6654             : fail:
    6655             :   return NULL;
    6656             : }
    6657             : 
    6658             : 
    6659           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_ParentProcessIDIsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6660             :   PyObject *resultobj = 0;
    6661             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6662           0 :   void *argp1 = 0 ;
    6663             :   int res1 = 0 ;
    6664           0 :   PyObject * obj0 = 0 ;
    6665             :   bool result;
    6666             :   
    6667           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_ParentProcessIDIsValid",&obj0)) SWIG_fail;
    6668           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6669           0 :   if (!SWIG_IsOK(res1)) {
    6670           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_ParentProcessIDIsValid" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6671             :   }
    6672           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6673             :   {
    6674             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6675           0 :     result = (bool)(arg1)->ParentProcessIDIsValid();
    6676             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6677             :   }
    6678             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6679           0 :   return resultobj;
    6680             : fail:
    6681             :   return NULL;
    6682             : }
    6683             : 
    6684             : 
    6685           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_GetListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6686             :   PyObject *resultobj = 0;
    6687             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6688           0 :   void *argp1 = 0 ;
    6689             :   int res1 = 0 ;
    6690           0 :   PyObject * obj0 = 0 ;
    6691           0 :   lldb::SBListener result;
    6692             :   
    6693           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBAttachInfo_GetListener",&obj0)) SWIG_fail;
    6694           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6695           0 :   if (!SWIG_IsOK(res1)) {
    6696           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_GetListener" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6697             :   }
    6698           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6699             :   {
    6700             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6701           0 :     result = (arg1)->GetListener();
    6702             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6703             :   }
    6704           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBListener(static_cast< const lldb::SBListener& >(result))), SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_OWN |  0 );
    6705           0 :   return resultobj;
    6706             : fail:
    6707             :   return NULL;
    6708             : }
    6709             : 
    6710             : 
    6711           0 : SWIGINTERN PyObject *_wrap_SBAttachInfo_SetListener(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6712             :   PyObject *resultobj = 0;
    6713             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6714             :   lldb::SBListener *arg2 = 0 ;
    6715           0 :   void *argp1 = 0 ;
    6716             :   int res1 = 0 ;
    6717           0 :   void *argp2 = 0 ;
    6718             :   int res2 = 0 ;
    6719           0 :   PyObject * obj0 = 0 ;
    6720           0 :   PyObject * obj1 = 0 ;
    6721             :   
    6722           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBAttachInfo_SetListener",&obj0,&obj1)) SWIG_fail;
    6723           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, 0 |  0 );
    6724           0 :   if (!SWIG_IsOK(res1)) {
    6725           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBAttachInfo_SetListener" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6726             :   }
    6727           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6728           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBListener,  0 );
    6729           0 :   if (!SWIG_IsOK(res2)) {
    6730           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBAttachInfo_SetListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
    6731             :   }
    6732           0 :   if (!argp2) {
    6733           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBAttachInfo_SetListener" "', argument " "2"" of type '" "lldb::SBListener &""'"); 
    6734             :   }
    6735             :   arg2 = reinterpret_cast< lldb::SBListener * >(argp2);
    6736             :   {
    6737             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6738           0 :     (arg1)->SetListener(*arg2);
    6739             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6740             :   }
    6741             :   resultobj = SWIG_Py_Void();
    6742           0 :   return resultobj;
    6743             : fail:
    6744             :   return NULL;
    6745             : }
    6746             : 
    6747             : 
    6748           0 : SWIGINTERN PyObject *_wrap_delete_SBAttachInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6749             :   PyObject *resultobj = 0;
    6750             :   lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ;
    6751           0 :   void *argp1 = 0 ;
    6752             :   int res1 = 0 ;
    6753           0 :   PyObject * obj0 = 0 ;
    6754             :   
    6755           0 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBAttachInfo",&obj0)) SWIG_fail;
    6756           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_DISOWN |  0 );
    6757           0 :   if (!SWIG_IsOK(res1)) {
    6758           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBAttachInfo" "', argument " "1"" of type '" "lldb::SBAttachInfo *""'"); 
    6759             :   }
    6760           0 :   arg1 = reinterpret_cast< lldb::SBAttachInfo * >(argp1);
    6761             :   {
    6762             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6763           0 :     delete arg1;
    6764             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6765             :   }
    6766             :   resultobj = SWIG_Py_Void();
    6767           0 :   return resultobj;
    6768             : fail:
    6769             :   return NULL;
    6770             : }
    6771             : 
    6772             : 
    6773         652 : SWIGINTERN PyObject *SBAttachInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6774             :   PyObject *obj;
    6775         652 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    6776         652 :   SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBAttachInfo, SWIG_NewClientData(obj));
    6777         652 :   return SWIG_Py_Void();
    6778             : }
    6779             : 
    6780           0 : SWIGINTERN PyObject *_wrap_new_SBBlock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6781             :   PyObject *resultobj = 0;
    6782             :   lldb::SBBlock *result = 0 ;
    6783             :   
    6784           0 :   if (!PyArg_ParseTuple(args,(char *)":new_SBBlock")) SWIG_fail;
    6785             :   {
    6786             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6787           0 :     result = (lldb::SBBlock *)new lldb::SBBlock();
    6788             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6789             :   }
    6790           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_NEW |  0 );
    6791           0 :   return resultobj;
    6792             : fail:
    6793           0 :   return NULL;
    6794             : }
    6795             : 
    6796             : 
    6797           0 : SWIGINTERN PyObject *_wrap_new_SBBlock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6798             :   PyObject *resultobj = 0;
    6799             :   lldb::SBBlock *arg1 = 0 ;
    6800           0 :   void *argp1 = 0 ;
    6801             :   int res1 = 0 ;
    6802           0 :   PyObject * obj0 = 0 ;
    6803             :   lldb::SBBlock *result = 0 ;
    6804             :   
    6805           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBBlock",&obj0)) SWIG_fail;
    6806           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBBlock,  0  | 0);
    6807           0 :   if (!SWIG_IsOK(res1)) {
    6808           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBlock" "', argument " "1"" of type '" "lldb::SBBlock const &""'"); 
    6809             :   }
    6810           0 :   if (!argp1) {
    6811           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBBlock" "', argument " "1"" of type '" "lldb::SBBlock const &""'"); 
    6812             :   }
    6813             :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6814             :   {
    6815             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6816           0 :     result = (lldb::SBBlock *)new lldb::SBBlock((lldb::SBBlock const &)*arg1);
    6817             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6818             :   }
    6819           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_NEW |  0 );
    6820           0 :   return resultobj;
    6821             : fail:
    6822             :   return NULL;
    6823             : }
    6824             : 
    6825             : 
    6826           1 : SWIGINTERN PyObject *_wrap_new_SBBlock(PyObject *self, PyObject *args) {
    6827             :   Py_ssize_t argc;
    6828           1 :   PyObject *argv[2] = {
    6829             :     0
    6830             :   };
    6831             :   Py_ssize_t ii;
    6832             :   
    6833           1 :   if (!PyTuple_Check(args)) SWIG_fail;
    6834           1 :   argc = args ? PyObject_Length(args) : 0;
    6835           1 :   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    6836           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    6837             :   }
    6838           1 :   if (argc == 0) {
    6839           1 :     return _wrap_new_SBBlock__SWIG_0(self, args);
    6840             :   }
    6841           0 :   if (argc == 1) {
    6842             :     int _v;
    6843           0 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBBlock, 0);
    6844           0 :     _v = SWIG_CheckState(res);
    6845             :     if (_v) {
    6846           0 :       return _wrap_new_SBBlock__SWIG_1(self, args);
    6847             :     }
    6848             :   }
    6849             :   
    6850           0 : fail:
    6851           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SBBlock'.\n"
    6852             :     "  Possible C/C++ prototypes are:\n"
    6853             :     "    lldb::SBBlock::SBBlock()\n"
    6854             :     "    lldb::SBBlock::SBBlock(lldb::SBBlock const &)\n");
    6855           0 :   return 0;
    6856             : }
    6857             : 
    6858             : 
    6859          10 : SWIGINTERN PyObject *_wrap_delete_SBBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6860             :   PyObject *resultobj = 0;
    6861             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6862          10 :   void *argp1 = 0 ;
    6863             :   int res1 = 0 ;
    6864          10 :   PyObject * obj0 = 0 ;
    6865             :   
    6866          10 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBBlock",&obj0)) SWIG_fail;
    6867          10 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_DISOWN |  0 );
    6868          10 :   if (!SWIG_IsOK(res1)) {
    6869           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBlock" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    6870             :   }
    6871          10 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6872             :   {
    6873             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6874          10 :     delete arg1;
    6875             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6876             :   }
    6877             :   resultobj = SWIG_Py_Void();
    6878          10 :   return resultobj;
    6879             : fail:
    6880             :   return NULL;
    6881             : }
    6882             : 
    6883             : 
    6884           1 : SWIGINTERN PyObject *_wrap_SBBlock_IsInlined(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6885             :   PyObject *resultobj = 0;
    6886             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6887           1 :   void *argp1 = 0 ;
    6888             :   int res1 = 0 ;
    6889           1 :   PyObject * obj0 = 0 ;
    6890             :   bool result;
    6891             :   
    6892           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_IsInlined",&obj0)) SWIG_fail;
    6893           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    6894           1 :   if (!SWIG_IsOK(res1)) {
    6895           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_IsInlined" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    6896             :   }
    6897           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6898             :   {
    6899             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6900           1 :     result = (bool)((lldb::SBBlock const *)arg1)->IsInlined();
    6901             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6902             :   }
    6903             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6904           1 :   return resultobj;
    6905             : fail:
    6906             :   return NULL;
    6907             : }
    6908             : 
    6909             : 
    6910           1 : SWIGINTERN PyObject *_wrap_SBBlock_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6911             :   PyObject *resultobj = 0;
    6912             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6913           1 :   void *argp1 = 0 ;
    6914             :   int res1 = 0 ;
    6915           1 :   PyObject * obj0 = 0 ;
    6916             :   bool result;
    6917             :   
    6918           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_IsValid",&obj0)) SWIG_fail;
    6919           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    6920           1 :   if (!SWIG_IsOK(res1)) {
    6921           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_IsValid" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    6922             :   }
    6923           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6924             :   {
    6925             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6926           1 :     result = (bool)((lldb::SBBlock const *)arg1)->IsValid();
    6927             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6928             :   }
    6929             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    6930           1 :   return resultobj;
    6931             : fail:
    6932             :   return NULL;
    6933             : }
    6934             : 
    6935             : 
    6936           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6937             :   PyObject *resultobj = 0;
    6938             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6939           1 :   void *argp1 = 0 ;
    6940             :   int res1 = 0 ;
    6941           1 :   PyObject * obj0 = 0 ;
    6942             :   char *result = 0 ;
    6943             :   
    6944           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetInlinedName",&obj0)) SWIG_fail;
    6945           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    6946           1 :   if (!SWIG_IsOK(res1)) {
    6947           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedName" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    6948             :   }
    6949           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6950             :   {
    6951             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6952           1 :     result = (char *)((lldb::SBBlock const *)arg1)->GetInlinedName();
    6953             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6954             :   }
    6955           1 :   resultobj = SWIG_FromCharPtr((const char *)result);
    6956           1 :   return resultobj;
    6957             : fail:
    6958             :   return NULL;
    6959             : }
    6960             : 
    6961             : 
    6962           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6963             :   PyObject *resultobj = 0;
    6964             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6965           1 :   void *argp1 = 0 ;
    6966             :   int res1 = 0 ;
    6967           1 :   PyObject * obj0 = 0 ;
    6968           2 :   lldb::SBFileSpec result;
    6969             :   
    6970           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetInlinedCallSiteFile",&obj0)) SWIG_fail;
    6971           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    6972           1 :   if (!SWIG_IsOK(res1)) {
    6973           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedCallSiteFile" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    6974             :   }
    6975           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    6976             :   {
    6977             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    6978           1 :     result = ((lldb::SBBlock const *)arg1)->GetInlinedCallSiteFile();
    6979             :     SWIG_PYTHON_THREAD_END_ALLOW;
    6980             :   }
    6981           1 :   resultobj = SWIG_NewPointerObj((new lldb::SBFileSpec(static_cast< const lldb::SBFileSpec& >(result))), SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_OWN |  0 );
    6982           1 :   return resultobj;
    6983             : fail:
    6984             :   return NULL;
    6985             : }
    6986             : 
    6987             : 
    6988           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteLine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    6989             :   PyObject *resultobj = 0;
    6990             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    6991           1 :   void *argp1 = 0 ;
    6992             :   int res1 = 0 ;
    6993           1 :   PyObject * obj0 = 0 ;
    6994             :   uint32_t result;
    6995             :   
    6996           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetInlinedCallSiteLine",&obj0)) SWIG_fail;
    6997           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    6998           1 :   if (!SWIG_IsOK(res1)) {
    6999           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedCallSiteLine" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    7000             :   }
    7001           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7002             :   {
    7003             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7004           1 :     result = (uint32_t)((lldb::SBBlock const *)arg1)->GetInlinedCallSiteLine();
    7005             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7006             :   }
    7007             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    7008           1 :   return resultobj;
    7009             : fail:
    7010             :   return NULL;
    7011             : }
    7012             : 
    7013             : 
    7014           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetInlinedCallSiteColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7015             :   PyObject *resultobj = 0;
    7016             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7017           1 :   void *argp1 = 0 ;
    7018             :   int res1 = 0 ;
    7019           1 :   PyObject * obj0 = 0 ;
    7020             :   uint32_t result;
    7021             :   
    7022           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetInlinedCallSiteColumn",&obj0)) SWIG_fail;
    7023           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7024           1 :   if (!SWIG_IsOK(res1)) {
    7025           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetInlinedCallSiteColumn" "', argument " "1"" of type '" "lldb::SBBlock const *""'"); 
    7026             :   }
    7027           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7028             :   {
    7029             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7030           1 :     result = (uint32_t)((lldb::SBBlock const *)arg1)->GetInlinedCallSiteColumn();
    7031             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7032             :   }
    7033             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    7034           1 :   return resultobj;
    7035             : fail:
    7036             :   return NULL;
    7037             : }
    7038             : 
    7039             : 
    7040           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7041             :   PyObject *resultobj = 0;
    7042             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7043           1 :   void *argp1 = 0 ;
    7044             :   int res1 = 0 ;
    7045           1 :   PyObject * obj0 = 0 ;
    7046           2 :   lldb::SBBlock result;
    7047             :   
    7048           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetParent",&obj0)) SWIG_fail;
    7049           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7050           1 :   if (!SWIG_IsOK(res1)) {
    7051           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetParent" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7052             :   }
    7053           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7054             :   {
    7055             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7056           1 :     result = (arg1)->GetParent();
    7057             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7058             :   }
    7059           1 :   resultobj = SWIG_NewPointerObj((new lldb::SBBlock(static_cast< const lldb::SBBlock& >(result))), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
    7060           1 :   return resultobj;
    7061             : fail:
    7062             :   return NULL;
    7063             : }
    7064             : 
    7065             : 
    7066           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetContainingInlinedBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7067             :   PyObject *resultobj = 0;
    7068             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7069           0 :   void *argp1 = 0 ;
    7070             :   int res1 = 0 ;
    7071           0 :   PyObject * obj0 = 0 ;
    7072           0 :   lldb::SBBlock result;
    7073             :   
    7074           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetContainingInlinedBlock",&obj0)) SWIG_fail;
    7075           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7076           0 :   if (!SWIG_IsOK(res1)) {
    7077           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetContainingInlinedBlock" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7078             :   }
    7079           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7080             :   {
    7081             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7082           0 :     result = (arg1)->GetContainingInlinedBlock();
    7083             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7084             :   }
    7085           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBBlock(static_cast< const lldb::SBBlock& >(result))), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
    7086           0 :   return resultobj;
    7087             : fail:
    7088             :   return NULL;
    7089             : }
    7090             : 
    7091             : 
    7092           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetSibling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7093             :   PyObject *resultobj = 0;
    7094             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7095           1 :   void *argp1 = 0 ;
    7096             :   int res1 = 0 ;
    7097           1 :   PyObject * obj0 = 0 ;
    7098           2 :   lldb::SBBlock result;
    7099             :   
    7100           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetSibling",&obj0)) SWIG_fail;
    7101           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7102           1 :   if (!SWIG_IsOK(res1)) {
    7103           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetSibling" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7104             :   }
    7105           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7106             :   {
    7107             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7108           1 :     result = (arg1)->GetSibling();
    7109             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7110             :   }
    7111           1 :   resultobj = SWIG_NewPointerObj((new lldb::SBBlock(static_cast< const lldb::SBBlock& >(result))), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
    7112           1 :   return resultobj;
    7113             : fail:
    7114             :   return NULL;
    7115             : }
    7116             : 
    7117             : 
    7118           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetFirstChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7119             :   PyObject *resultobj = 0;
    7120             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7121           1 :   void *argp1 = 0 ;
    7122             :   int res1 = 0 ;
    7123           1 :   PyObject * obj0 = 0 ;
    7124           2 :   lldb::SBBlock result;
    7125             :   
    7126           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetFirstChild",&obj0)) SWIG_fail;
    7127           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7128           1 :   if (!SWIG_IsOK(res1)) {
    7129           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetFirstChild" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7130             :   }
    7131           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7132             :   {
    7133             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7134           1 :     result = (arg1)->GetFirstChild();
    7135             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7136             :   }
    7137           1 :   resultobj = SWIG_NewPointerObj((new lldb::SBBlock(static_cast< const lldb::SBBlock& >(result))), SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_OWN |  0 );
    7138           1 :   return resultobj;
    7139             : fail:
    7140             :   return NULL;
    7141             : }
    7142             : 
    7143             : 
    7144           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetNumRanges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7145             :   PyObject *resultobj = 0;
    7146             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7147           0 :   void *argp1 = 0 ;
    7148             :   int res1 = 0 ;
    7149           0 :   PyObject * obj0 = 0 ;
    7150             :   uint32_t result;
    7151             :   
    7152           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock_GetNumRanges",&obj0)) SWIG_fail;
    7153           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7154           0 :   if (!SWIG_IsOK(res1)) {
    7155           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetNumRanges" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7156             :   }
    7157           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7158             :   {
    7159             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7160           0 :     result = (uint32_t)(arg1)->GetNumRanges();
    7161             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7162             :   }
    7163             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    7164           0 :   return resultobj;
    7165             : fail:
    7166             :   return NULL;
    7167             : }
    7168             : 
    7169             : 
    7170           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetRangeStartAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7171             :   PyObject *resultobj = 0;
    7172             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7173             :   uint32_t arg2 ;
    7174           0 :   void *argp1 = 0 ;
    7175             :   int res1 = 0 ;
    7176             :   unsigned int val2 ;
    7177             :   int ecode2 = 0 ;
    7178           0 :   PyObject * obj0 = 0 ;
    7179           0 :   PyObject * obj1 = 0 ;
    7180           0 :   lldb::SBAddress result;
    7181             :   
    7182           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBlock_GetRangeStartAddress",&obj0,&obj1)) SWIG_fail;
    7183           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7184           0 :   if (!SWIG_IsOK(res1)) {
    7185           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetRangeStartAddress" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7186             :   }
    7187           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7188           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    7189           0 :   if (!SWIG_IsOK(ecode2)) {
    7190           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBlock_GetRangeStartAddress" "', argument " "2"" of type '" "uint32_t""'");
    7191             :   } 
    7192             :   arg2 = static_cast< uint32_t >(val2);
    7193             :   {
    7194             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7195           0 :     result = (arg1)->GetRangeStartAddress(arg2);
    7196             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7197             :   }
    7198           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBAddress(static_cast< const lldb::SBAddress& >(result))), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
    7199           0 :   return resultobj;
    7200             : fail:
    7201             :   return NULL;
    7202             : }
    7203             : 
    7204             : 
    7205           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetRangeEndAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7206             :   PyObject *resultobj = 0;
    7207             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7208             :   uint32_t arg2 ;
    7209           0 :   void *argp1 = 0 ;
    7210             :   int res1 = 0 ;
    7211             :   unsigned int val2 ;
    7212             :   int ecode2 = 0 ;
    7213           0 :   PyObject * obj0 = 0 ;
    7214           0 :   PyObject * obj1 = 0 ;
    7215           0 :   lldb::SBAddress result;
    7216             :   
    7217           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBlock_GetRangeEndAddress",&obj0,&obj1)) SWIG_fail;
    7218           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7219           0 :   if (!SWIG_IsOK(res1)) {
    7220           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetRangeEndAddress" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7221             :   }
    7222           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7223           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    7224           0 :   if (!SWIG_IsOK(ecode2)) {
    7225           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBlock_GetRangeEndAddress" "', argument " "2"" of type '" "uint32_t""'");
    7226             :   } 
    7227             :   arg2 = static_cast< uint32_t >(val2);
    7228             :   {
    7229             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7230           0 :     result = (arg1)->GetRangeEndAddress(arg2);
    7231             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7232             :   }
    7233           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBAddress(static_cast< const lldb::SBAddress& >(result))), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
    7234           0 :   return resultobj;
    7235             : fail:
    7236             :   return NULL;
    7237             : }
    7238             : 
    7239             : 
    7240           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetRangeIndexForBlockAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7241             :   PyObject *resultobj = 0;
    7242             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7243           0 :   lldb::SBAddress arg2 ;
    7244           0 :   void *argp1 = 0 ;
    7245             :   int res1 = 0 ;
    7246             :   void *argp2 ;
    7247             :   int res2 = 0 ;
    7248           0 :   PyObject * obj0 = 0 ;
    7249           0 :   PyObject * obj1 = 0 ;
    7250             :   uint32_t result;
    7251             :   
    7252           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBlock_GetRangeIndexForBlockAddress",&obj0,&obj1)) SWIG_fail;
    7253           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7254           0 :   if (!SWIG_IsOK(res1)) {
    7255           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetRangeIndexForBlockAddress" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7256             :   }
    7257           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7258             :   {
    7259           0 :     res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBAddress,  0  | 0);
    7260           0 :     if (!SWIG_IsOK(res2)) {
    7261           0 :       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetRangeIndexForBlockAddress" "', argument " "2"" of type '" "lldb::SBAddress""'"); 
    7262             :     }  
    7263           0 :     if (!argp2) {
    7264           0 :       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBlock_GetRangeIndexForBlockAddress" "', argument " "2"" of type '" "lldb::SBAddress""'");
    7265             :     } else {
    7266             :       lldb::SBAddress * temp = reinterpret_cast< lldb::SBAddress * >(argp2);
    7267           0 :       arg2 = *temp;
    7268           0 :       if (SWIG_IsNewObj(res2)) delete temp;
    7269             :     }
    7270             :   }
    7271             :   {
    7272             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7273           0 :     result = (uint32_t)(arg1)->GetRangeIndexForBlockAddress(arg2);
    7274             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7275             :   }
    7276             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    7277           0 :   return resultobj;
    7278             : fail:
    7279             :   return NULL;
    7280             : }
    7281             : 
    7282             : 
    7283           1 : SWIGINTERN PyObject *_wrap_SBBlock_GetDescription(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7284             :   PyObject *resultobj = 0;
    7285             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7286             :   lldb::SBStream *arg2 = 0 ;
    7287           1 :   void *argp1 = 0 ;
    7288             :   int res1 = 0 ;
    7289           1 :   void *argp2 = 0 ;
    7290             :   int res2 = 0 ;
    7291           1 :   PyObject * obj0 = 0 ;
    7292           1 :   PyObject * obj1 = 0 ;
    7293             :   bool result;
    7294             :   
    7295           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBlock_GetDescription",&obj0,&obj1)) SWIG_fail;
    7296           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7297           1 :   if (!SWIG_IsOK(res1)) {
    7298           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetDescription" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7299             :   }
    7300           1 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7301           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
    7302           1 :   if (!SWIG_IsOK(res2)) {
    7303           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    7304             :   }
    7305           1 :   if (!argp2) {
    7306           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBlock_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    7307             :   }
    7308             :   arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
    7309             :   {
    7310             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7311           1 :     result = (bool)(arg1)->GetDescription(*arg2);
    7312             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7313             :   }
    7314             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7315           1 :   return resultobj;
    7316             : fail:
    7317             :   return NULL;
    7318             : }
    7319             : 
    7320             : 
    7321           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetVariables__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7322             :   PyObject *resultobj = 0;
    7323             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7324             :   lldb::SBFrame *arg2 = 0 ;
    7325             :   bool arg3 ;
    7326             :   bool arg4 ;
    7327             :   bool arg5 ;
    7328             :   lldb::DynamicValueType arg6 ;
    7329           0 :   void *argp1 = 0 ;
    7330             :   int res1 = 0 ;
    7331           0 :   void *argp2 = 0 ;
    7332             :   int res2 = 0 ;
    7333             :   bool val3 ;
    7334             :   int ecode3 = 0 ;
    7335             :   bool val4 ;
    7336             :   int ecode4 = 0 ;
    7337             :   bool val5 ;
    7338             :   int ecode5 = 0 ;
    7339             :   int val6 ;
    7340             :   int ecode6 = 0 ;
    7341           0 :   PyObject * obj0 = 0 ;
    7342           0 :   PyObject * obj1 = 0 ;
    7343           0 :   PyObject * obj2 = 0 ;
    7344           0 :   PyObject * obj3 = 0 ;
    7345           0 :   PyObject * obj4 = 0 ;
    7346           0 :   PyObject * obj5 = 0 ;
    7347           0 :   lldb::SBValueList result;
    7348             :   
    7349           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOOOO:SBBlock_GetVariables",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
    7350           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7351           0 :   if (!SWIG_IsOK(res1)) {
    7352           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetVariables" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7353             :   }
    7354           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7355           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBFrame,  0 );
    7356           0 :   if (!SWIG_IsOK(res2)) {
    7357           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
    7358             :   }
    7359           0 :   if (!argp2) {
    7360           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBFrame &""'"); 
    7361             :   }
    7362             :   arg2 = reinterpret_cast< lldb::SBFrame * >(argp2);
    7363           0 :   ecode3 = SWIG_AsVal_bool(obj2, &val3);
    7364             :   if (!SWIG_IsOK(ecode3)) {
    7365           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBlock_GetVariables" "', argument " "3"" of type '" "bool""'");
    7366             :   } 
    7367             :   arg3 = static_cast< bool >(val3);
    7368           0 :   ecode4 = SWIG_AsVal_bool(obj3, &val4);
    7369             :   if (!SWIG_IsOK(ecode4)) {
    7370           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBBlock_GetVariables" "', argument " "4"" of type '" "bool""'");
    7371             :   } 
    7372             :   arg4 = static_cast< bool >(val4);
    7373           0 :   ecode5 = SWIG_AsVal_bool(obj4, &val5);
    7374             :   if (!SWIG_IsOK(ecode5)) {
    7375           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBBlock_GetVariables" "', argument " "5"" of type '" "bool""'");
    7376             :   } 
    7377             :   arg5 = static_cast< bool >(val5);
    7378           0 :   ecode6 = SWIG_AsVal_int(obj5, &val6);
    7379           0 :   if (!SWIG_IsOK(ecode6)) {
    7380           0 :     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SBBlock_GetVariables" "', argument " "6"" of type '" "lldb::DynamicValueType""'");
    7381             :   } 
    7382           0 :   arg6 = static_cast< lldb::DynamicValueType >(val6);
    7383             :   {
    7384             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7385           0 :     result = (arg1)->GetVariables(*arg2,arg3,arg4,arg5,arg6);
    7386             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7387             :   }
    7388           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBValueList(static_cast< const lldb::SBValueList& >(result))), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
    7389           0 :   return resultobj;
    7390             : fail:
    7391             :   return NULL;
    7392             : }
    7393             : 
    7394             : 
    7395           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetVariables__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7396             :   PyObject *resultobj = 0;
    7397             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7398             :   lldb::SBTarget *arg2 = 0 ;
    7399             :   bool arg3 ;
    7400             :   bool arg4 ;
    7401             :   bool arg5 ;
    7402           0 :   void *argp1 = 0 ;
    7403             :   int res1 = 0 ;
    7404           0 :   void *argp2 = 0 ;
    7405             :   int res2 = 0 ;
    7406             :   bool val3 ;
    7407             :   int ecode3 = 0 ;
    7408             :   bool val4 ;
    7409             :   int ecode4 = 0 ;
    7410             :   bool val5 ;
    7411             :   int ecode5 = 0 ;
    7412           0 :   PyObject * obj0 = 0 ;
    7413           0 :   PyObject * obj1 = 0 ;
    7414           0 :   PyObject * obj2 = 0 ;
    7415           0 :   PyObject * obj3 = 0 ;
    7416           0 :   PyObject * obj4 = 0 ;
    7417           0 :   lldb::SBValueList result;
    7418             :   
    7419           0 :   if (!PyArg_ParseTuple(args,(char *)"OOOOO:SBBlock_GetVariables",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
    7420           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7421           0 :   if (!SWIG_IsOK(res1)) {
    7422           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock_GetVariables" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7423             :   }
    7424           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7425           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBTarget,  0 );
    7426           0 :   if (!SWIG_IsOK(res2)) {
    7427           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
    7428             :   }
    7429           0 :   if (!argp2) {
    7430           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBlock_GetVariables" "', argument " "2"" of type '" "lldb::SBTarget &""'"); 
    7431             :   }
    7432             :   arg2 = reinterpret_cast< lldb::SBTarget * >(argp2);
    7433           0 :   ecode3 = SWIG_AsVal_bool(obj2, &val3);
    7434             :   if (!SWIG_IsOK(ecode3)) {
    7435           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBlock_GetVariables" "', argument " "3"" of type '" "bool""'");
    7436             :   } 
    7437             :   arg3 = static_cast< bool >(val3);
    7438           0 :   ecode4 = SWIG_AsVal_bool(obj3, &val4);
    7439             :   if (!SWIG_IsOK(ecode4)) {
    7440           0 :     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SBBlock_GetVariables" "', argument " "4"" of type '" "bool""'");
    7441             :   } 
    7442             :   arg4 = static_cast< bool >(val4);
    7443           0 :   ecode5 = SWIG_AsVal_bool(obj4, &val5);
    7444             :   if (!SWIG_IsOK(ecode5)) {
    7445           0 :     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SBBlock_GetVariables" "', argument " "5"" of type '" "bool""'");
    7446             :   } 
    7447             :   arg5 = static_cast< bool >(val5);
    7448             :   {
    7449             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7450           0 :     result = (arg1)->GetVariables(*arg2,arg3,arg4,arg5);
    7451             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7452             :   }
    7453           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBValueList(static_cast< const lldb::SBValueList& >(result))), SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_OWN |  0 );
    7454           0 :   return resultobj;
    7455             : fail:
    7456             :   return NULL;
    7457             : }
    7458             : 
    7459             : 
    7460           0 : SWIGINTERN PyObject *_wrap_SBBlock_GetVariables(PyObject *self, PyObject *args) {
    7461             :   Py_ssize_t argc;
    7462           0 :   PyObject *argv[7] = {
    7463             :     0
    7464             :   };
    7465             :   Py_ssize_t ii;
    7466             :   
    7467           0 :   if (!PyTuple_Check(args)) SWIG_fail;
    7468           0 :   argc = args ? PyObject_Length(args) : 0;
    7469           0 :   for (ii = 0; (ii < 6) && (ii < argc); ii++) {
    7470           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    7471             :   }
    7472           0 :   if (argc == 5) {
    7473             :     int _v;
    7474           0 :     void *vptr = 0;
    7475           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBlock, 0);
    7476           0 :     _v = SWIG_CheckState(res);
    7477             :     if (_v) {
    7478           0 :       void *vptr = 0;
    7479           0 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBTarget, 0);
    7480           0 :       _v = SWIG_CheckState(res);
    7481             :       if (_v) {
    7482             :         {
    7483           0 :           int res = SWIG_AsVal_bool(argv[2], NULL);
    7484             :           _v = SWIG_CheckState(res);
    7485             :         }
    7486             :         if (_v) {
    7487             :           {
    7488           0 :             int res = SWIG_AsVal_bool(argv[3], NULL);
    7489             :             _v = SWIG_CheckState(res);
    7490             :           }
    7491             :           if (_v) {
    7492             :             {
    7493           0 :               int res = SWIG_AsVal_bool(argv[4], NULL);
    7494             :               _v = SWIG_CheckState(res);
    7495             :             }
    7496             :             if (_v) {
    7497           0 :               return _wrap_SBBlock_GetVariables__SWIG_1(self, args);
    7498             :             }
    7499             :           }
    7500             :         }
    7501             :       }
    7502             :     }
    7503             :   }
    7504           0 :   if (argc == 6) {
    7505             :     int _v;
    7506           0 :     void *vptr = 0;
    7507           0 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBlock, 0);
    7508           0 :     _v = SWIG_CheckState(res);
    7509             :     if (_v) {
    7510           0 :       void *vptr = 0;
    7511           0 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBFrame, 0);
    7512           0 :       _v = SWIG_CheckState(res);
    7513             :       if (_v) {
    7514             :         {
    7515           0 :           int res = SWIG_AsVal_bool(argv[2], NULL);
    7516             :           _v = SWIG_CheckState(res);
    7517             :         }
    7518             :         if (_v) {
    7519             :           {
    7520           0 :             int res = SWIG_AsVal_bool(argv[3], NULL);
    7521             :             _v = SWIG_CheckState(res);
    7522             :           }
    7523             :           if (_v) {
    7524             :             {
    7525           0 :               int res = SWIG_AsVal_bool(argv[4], NULL);
    7526             :               _v = SWIG_CheckState(res);
    7527             :             }
    7528             :             if (_v) {
    7529             :               {
    7530           0 :                 int res = SWIG_AsVal_int(argv[5], NULL);
    7531           0 :                 _v = SWIG_CheckState(res);
    7532             :               }
    7533             :               if (_v) {
    7534           0 :                 return _wrap_SBBlock_GetVariables__SWIG_0(self, args);
    7535             :               }
    7536             :             }
    7537             :           }
    7538             :         }
    7539             :       }
    7540             :     }
    7541             :   }
    7542             :   
    7543           0 : fail:
    7544           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SBBlock_GetVariables'.\n"
    7545             :     "  Possible C/C++ prototypes are:\n"
    7546             :     "    lldb::SBBlock::GetVariables(lldb::SBFrame &,bool,bool,bool,lldb::DynamicValueType)\n"
    7547             :     "    lldb::SBBlock::GetVariables(lldb::SBTarget &,bool,bool,bool)\n");
    7548           0 :   return 0;
    7549             : }
    7550             : 
    7551             : 
    7552           0 : SWIGINTERN PyObject *_wrap_SBBlock___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7553             :   PyObject *resultobj = 0;
    7554             :   lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ;
    7555           0 :   void *argp1 = 0 ;
    7556             :   int res1 = 0 ;
    7557           0 :   PyObject * obj0 = 0 ;
    7558             :   PyObject *result = 0 ;
    7559             :   
    7560           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBlock___str__",&obj0)) SWIG_fail;
    7561           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBlock, 0 |  0 );
    7562           0 :   if (!SWIG_IsOK(res1)) {
    7563           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBlock___str__" "', argument " "1"" of type '" "lldb::SBBlock *""'"); 
    7564             :   }
    7565           0 :   arg1 = reinterpret_cast< lldb::SBBlock * >(argp1);
    7566           0 :   result = (PyObject *)lldb_SBBlock___str__(arg1);
    7567             :   resultobj = result;
    7568           0 :   return resultobj;
    7569             : fail:
    7570             :   return NULL;
    7571             : }
    7572             : 
    7573             : 
    7574         652 : SWIGINTERN PyObject *SBBlock_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7575             :   PyObject *obj;
    7576         652 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    7577         652 :   SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBlock, SWIG_NewClientData(obj));
    7578         652 :   return SWIG_Py_Void();
    7579             : }
    7580             : 
    7581           0 : SWIGINTERN PyObject *_wrap_new_SBBreakpoint__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7582             :   PyObject *resultobj = 0;
    7583             :   lldb::SBBreakpoint *result = 0 ;
    7584             :   
    7585           0 :   if (!PyArg_ParseTuple(args,(char *)":new_SBBreakpoint")) SWIG_fail;
    7586             :   {
    7587             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7588           0 :     result = (lldb::SBBreakpoint *)new lldb::SBBreakpoint();
    7589             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7590             :   }
    7591           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NEW |  0 );
    7592           0 :   return resultobj;
    7593             : fail:
    7594           0 :   return NULL;
    7595             : }
    7596             : 
    7597             : 
    7598           0 : SWIGINTERN PyObject *_wrap_new_SBBreakpoint__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7599             :   PyObject *resultobj = 0;
    7600             :   lldb::SBBreakpoint *arg1 = 0 ;
    7601           0 :   void *argp1 = 0 ;
    7602             :   int res1 = 0 ;
    7603           0 :   PyObject * obj0 = 0 ;
    7604             :   lldb::SBBreakpoint *result = 0 ;
    7605             :   
    7606           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBBreakpoint",&obj0)) SWIG_fail;
    7607           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
    7608           0 :   if (!SWIG_IsOK(res1)) {
    7609           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpoint" "', argument " "1"" of type '" "lldb::SBBreakpoint const &""'"); 
    7610             :   }
    7611           0 :   if (!argp1) {
    7612           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBBreakpoint" "', argument " "1"" of type '" "lldb::SBBreakpoint const &""'"); 
    7613             :   }
    7614             :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7615             :   {
    7616             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7617           0 :     result = (lldb::SBBreakpoint *)new lldb::SBBreakpoint((lldb::SBBreakpoint const &)*arg1);
    7618             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7619             :   }
    7620           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NEW |  0 );
    7621           0 :   return resultobj;
    7622             : fail:
    7623             :   return NULL;
    7624             : }
    7625             : 
    7626             : 
    7627           1 : SWIGINTERN PyObject *_wrap_new_SBBreakpoint(PyObject *self, PyObject *args) {
    7628             :   Py_ssize_t argc;
    7629           1 :   PyObject *argv[2] = {
    7630             :     0
    7631             :   };
    7632             :   Py_ssize_t ii;
    7633             :   
    7634           1 :   if (!PyTuple_Check(args)) SWIG_fail;
    7635           1 :   argc = args ? PyObject_Length(args) : 0;
    7636           1 :   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    7637           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    7638             :   }
    7639           1 :   if (argc == 0) {
    7640           1 :     return _wrap_new_SBBreakpoint__SWIG_0(self, args);
    7641             :   }
    7642           0 :   if (argc == 1) {
    7643             :     int _v;
    7644           0 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBBreakpoint, 0);
    7645           0 :     _v = SWIG_CheckState(res);
    7646             :     if (_v) {
    7647           0 :       return _wrap_new_SBBreakpoint__SWIG_1(self, args);
    7648             :     }
    7649             :   }
    7650             :   
    7651           0 : fail:
    7652           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SBBreakpoint'.\n"
    7653             :     "  Possible C/C++ prototypes are:\n"
    7654             :     "    lldb::SBBreakpoint::SBBreakpoint()\n"
    7655             :     "    lldb::SBBreakpoint::SBBreakpoint(lldb::SBBreakpoint const &)\n");
    7656           0 :   return 0;
    7657             : }
    7658             : 
    7659             : 
    7660         617 : SWIGINTERN PyObject *_wrap_delete_SBBreakpoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7661             :   PyObject *resultobj = 0;
    7662             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7663         617 :   void *argp1 = 0 ;
    7664             :   int res1 = 0 ;
    7665         617 :   PyObject * obj0 = 0 ;
    7666             :   
    7667         617 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBBreakpoint",&obj0)) SWIG_fail;
    7668         617 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_DISOWN |  0 );
    7669         617 :   if (!SWIG_IsOK(res1)) {
    7670           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBreakpoint" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7671             :   }
    7672         617 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7673             :   {
    7674             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7675         617 :     delete arg1;
    7676             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7677             :   }
    7678             :   resultobj = SWIG_Py_Void();
    7679         617 :   return resultobj;
    7680             : fail:
    7681             :   return NULL;
    7682             : }
    7683             : 
    7684             : 
    7685         167 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7686             :   PyObject *resultobj = 0;
    7687             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7688         167 :   void *argp1 = 0 ;
    7689             :   int res1 = 0 ;
    7690         167 :   PyObject * obj0 = 0 ;
    7691             :   lldb::break_id_t result;
    7692             :   
    7693         167 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetID",&obj0)) SWIG_fail;
    7694         167 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7695         167 :   if (!SWIG_IsOK(res1)) {
    7696           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetID" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    7697             :   }
    7698         167 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7699             :   {
    7700             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7701         167 :     result = (lldb::break_id_t)((lldb::SBBreakpoint const *)arg1)->GetID();
    7702             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7703             :   }
    7704             :   resultobj = SWIG_From_int(static_cast< int >(result));
    7705         167 :   return resultobj;
    7706             : fail:
    7707             :   return NULL;
    7708             : }
    7709             : 
    7710             : 
    7711         315 : SWIGINTERN PyObject *_wrap_SBBreakpoint_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7712             :   PyObject *resultobj = 0;
    7713             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7714         315 :   void *argp1 = 0 ;
    7715             :   int res1 = 0 ;
    7716         315 :   PyObject * obj0 = 0 ;
    7717             :   bool result;
    7718             :   
    7719         315 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_IsValid",&obj0)) SWIG_fail;
    7720         315 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7721         315 :   if (!SWIG_IsOK(res1)) {
    7722           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsValid" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    7723             :   }
    7724         315 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7725             :   {
    7726             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7727         315 :     result = (bool)((lldb::SBBreakpoint const *)arg1)->IsValid();
    7728             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7729             :   }
    7730             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7731         315 :   return resultobj;
    7732             : fail:
    7733             :   return NULL;
    7734             : }
    7735             : 
    7736             : 
    7737           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_ClearAllBreakpointSites(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7738             :   PyObject *resultobj = 0;
    7739             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7740           2 :   void *argp1 = 0 ;
    7741             :   int res1 = 0 ;
    7742           2 :   PyObject * obj0 = 0 ;
    7743             :   
    7744           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_ClearAllBreakpointSites",&obj0)) SWIG_fail;
    7745           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7746           2 :   if (!SWIG_IsOK(res1)) {
    7747           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_ClearAllBreakpointSites" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7748             :   }
    7749           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7750             :   {
    7751             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7752           2 :     (arg1)->ClearAllBreakpointSites();
    7753             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7754             :   }
    7755             :   resultobj = SWIG_Py_Void();
    7756           2 :   return resultobj;
    7757             : fail:
    7758             :   return NULL;
    7759             : }
    7760             : 
    7761             : 
    7762           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationByAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7763             :   PyObject *resultobj = 0;
    7764             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7765             :   lldb::addr_t arg2 ;
    7766           2 :   void *argp1 = 0 ;
    7767             :   int res1 = 0 ;
    7768             :   unsigned long long val2 ;
    7769             :   int ecode2 = 0 ;
    7770           2 :   PyObject * obj0 = 0 ;
    7771           2 :   PyObject * obj1 = 0 ;
    7772           4 :   lldb::SBBreakpointLocation result;
    7773             :   
    7774           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_FindLocationByAddress",&obj0,&obj1)) SWIG_fail;
    7775           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7776           2 :   if (!SWIG_IsOK(res1)) {
    7777           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_FindLocationByAddress" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7778             :   }
    7779           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7780           2 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    7781           2 :   if (!SWIG_IsOK(ecode2)) {
    7782           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_FindLocationByAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
    7783             :   } 
    7784           2 :   arg2 = static_cast< lldb::addr_t >(val2);
    7785             :   {
    7786             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7787           2 :     result = (arg1)->FindLocationByAddress(arg2);
    7788             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7789             :   }
    7790           2 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(static_cast< const lldb::SBBreakpointLocation& >(result))), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
    7791           2 :   return resultobj;
    7792             : fail:
    7793             :   return NULL;
    7794             : }
    7795             : 
    7796             : 
    7797           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationIDByAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7798             :   PyObject *resultobj = 0;
    7799             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7800             :   lldb::addr_t arg2 ;
    7801           2 :   void *argp1 = 0 ;
    7802             :   int res1 = 0 ;
    7803             :   unsigned long long val2 ;
    7804             :   int ecode2 = 0 ;
    7805           2 :   PyObject * obj0 = 0 ;
    7806           2 :   PyObject * obj1 = 0 ;
    7807             :   lldb::break_id_t result;
    7808             :   
    7809           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_FindLocationIDByAddress",&obj0,&obj1)) SWIG_fail;
    7810           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7811           2 :   if (!SWIG_IsOK(res1)) {
    7812           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_FindLocationIDByAddress" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7813             :   }
    7814           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7815           2 :   ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(obj1, &val2);
    7816           2 :   if (!SWIG_IsOK(ecode2)) {
    7817           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_FindLocationIDByAddress" "', argument " "2"" of type '" "lldb::addr_t""'");
    7818             :   } 
    7819           2 :   arg2 = static_cast< lldb::addr_t >(val2);
    7820             :   {
    7821             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7822           2 :     result = (lldb::break_id_t)(arg1)->FindLocationIDByAddress(arg2);
    7823             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7824             :   }
    7825             :   resultobj = SWIG_From_int(static_cast< int >(result));
    7826           2 :   return resultobj;
    7827             : fail:
    7828             :   return NULL;
    7829             : }
    7830             : 
    7831             : 
    7832           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_FindLocationByID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7833             :   PyObject *resultobj = 0;
    7834             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7835             :   lldb::break_id_t arg2 ;
    7836           2 :   void *argp1 = 0 ;
    7837             :   int res1 = 0 ;
    7838             :   int val2 ;
    7839             :   int ecode2 = 0 ;
    7840           2 :   PyObject * obj0 = 0 ;
    7841           2 :   PyObject * obj1 = 0 ;
    7842           4 :   lldb::SBBreakpointLocation result;
    7843             :   
    7844           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_FindLocationByID",&obj0,&obj1)) SWIG_fail;
    7845           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7846           2 :   if (!SWIG_IsOK(res1)) {
    7847           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_FindLocationByID" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7848             :   }
    7849           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7850           2 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    7851           2 :   if (!SWIG_IsOK(ecode2)) {
    7852           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_FindLocationByID" "', argument " "2"" of type '" "lldb::break_id_t""'");
    7853             :   } 
    7854             :   arg2 = static_cast< lldb::break_id_t >(val2);
    7855             :   {
    7856             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7857           2 :     result = (arg1)->FindLocationByID(arg2);
    7858             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7859             :   }
    7860           2 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(static_cast< const lldb::SBBreakpointLocation& >(result))), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
    7861           2 :   return resultobj;
    7862             : fail:
    7863             :   return NULL;
    7864             : }
    7865             : 
    7866             : 
    7867         137 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetLocationAtIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7868             :   PyObject *resultobj = 0;
    7869             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7870             :   uint32_t arg2 ;
    7871         137 :   void *argp1 = 0 ;
    7872             :   int res1 = 0 ;
    7873             :   unsigned int val2 ;
    7874             :   int ecode2 = 0 ;
    7875         137 :   PyObject * obj0 = 0 ;
    7876         137 :   PyObject * obj1 = 0 ;
    7877         274 :   lldb::SBBreakpointLocation result;
    7878             :   
    7879         137 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_GetLocationAtIndex",&obj0,&obj1)) SWIG_fail;
    7880         137 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7881         137 :   if (!SWIG_IsOK(res1)) {
    7882           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetLocationAtIndex" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7883             :   }
    7884         137 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7885         137 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    7886         137 :   if (!SWIG_IsOK(ecode2)) {
    7887           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_GetLocationAtIndex" "', argument " "2"" of type '" "uint32_t""'");
    7888             :   } 
    7889             :   arg2 = static_cast< uint32_t >(val2);
    7890             :   {
    7891             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7892         137 :     result = (arg1)->GetLocationAtIndex(arg2);
    7893             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7894             :   }
    7895         137 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(static_cast< const lldb::SBBreakpointLocation& >(result))), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
    7896         137 :   return resultobj;
    7897             : fail:
    7898             :   return NULL;
    7899             : }
    7900             : 
    7901             : 
    7902          10 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7903             :   PyObject *resultobj = 0;
    7904             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7905             :   bool arg2 ;
    7906          10 :   void *argp1 = 0 ;
    7907             :   int res1 = 0 ;
    7908             :   bool val2 ;
    7909             :   int ecode2 = 0 ;
    7910          10 :   PyObject * obj0 = 0 ;
    7911          10 :   PyObject * obj1 = 0 ;
    7912             :   
    7913          10 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetEnabled",&obj0,&obj1)) SWIG_fail;
    7914          10 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7915          10 :   if (!SWIG_IsOK(res1)) {
    7916           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetEnabled" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7917             :   }
    7918          10 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7919          10 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    7920             :   if (!SWIG_IsOK(ecode2)) {
    7921           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetEnabled" "', argument " "2"" of type '" "bool""'");
    7922             :   } 
    7923             :   arg2 = static_cast< bool >(val2);
    7924             :   {
    7925             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7926          10 :     (arg1)->SetEnabled(arg2);
    7927             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7928             :   }
    7929             :   resultobj = SWIG_Py_Void();
    7930          10 :   return resultobj;
    7931             : fail:
    7932             :   return NULL;
    7933             : }
    7934             : 
    7935             : 
    7936          14 : SWIGINTERN PyObject *_wrap_SBBreakpoint_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7937             :   PyObject *resultobj = 0;
    7938             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7939          14 :   void *argp1 = 0 ;
    7940             :   int res1 = 0 ;
    7941          14 :   PyObject * obj0 = 0 ;
    7942             :   bool result;
    7943             :   
    7944          14 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_IsEnabled",&obj0)) SWIG_fail;
    7945          14 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7946          14 :   if (!SWIG_IsOK(res1)) {
    7947           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsEnabled" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7948             :   }
    7949          14 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7950             :   {
    7951             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7952          14 :     result = (bool)(arg1)->IsEnabled();
    7953             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7954             :   }
    7955             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    7956          14 :   return resultobj;
    7957             : fail:
    7958             :   return NULL;
    7959             : }
    7960             : 
    7961             : 
    7962           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7963             :   PyObject *resultobj = 0;
    7964             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7965             :   bool arg2 ;
    7966           4 :   void *argp1 = 0 ;
    7967             :   int res1 = 0 ;
    7968             :   bool val2 ;
    7969             :   int ecode2 = 0 ;
    7970           4 :   PyObject * obj0 = 0 ;
    7971           4 :   PyObject * obj1 = 0 ;
    7972             :   
    7973           4 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetOneShot",&obj0,&obj1)) SWIG_fail;
    7974           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    7975           4 :   if (!SWIG_IsOK(res1)) {
    7976           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetOneShot" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    7977             :   }
    7978           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    7979           4 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    7980             :   if (!SWIG_IsOK(ecode2)) {
    7981           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetOneShot" "', argument " "2"" of type '" "bool""'");
    7982             :   } 
    7983             :   arg2 = static_cast< bool >(val2);
    7984             :   {
    7985             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    7986           4 :     (arg1)->SetOneShot(arg2);
    7987             :     SWIG_PYTHON_THREAD_END_ALLOW;
    7988             :   }
    7989             :   resultobj = SWIG_Py_Void();
    7990           4 :   return resultobj;
    7991             : fail:
    7992             :   return NULL;
    7993             : }
    7994             : 
    7995             : 
    7996           3 : SWIGINTERN PyObject *_wrap_SBBreakpoint_IsOneShot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    7997             :   PyObject *resultobj = 0;
    7998             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    7999           3 :   void *argp1 = 0 ;
    8000             :   int res1 = 0 ;
    8001           3 :   PyObject * obj0 = 0 ;
    8002             :   bool result;
    8003             :   
    8004           3 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_IsOneShot",&obj0)) SWIG_fail;
    8005           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8006           3 :   if (!SWIG_IsOK(res1)) {
    8007           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsOneShot" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8008             :   }
    8009           3 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8010             :   {
    8011             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8012           3 :     result = (bool)(arg1)->IsOneShot();
    8013             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8014             :   }
    8015             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8016           3 :   return resultobj;
    8017             : fail:
    8018             :   return NULL;
    8019             : }
    8020             : 
    8021             : 
    8022           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint_IsInternal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8023             :   PyObject *resultobj = 0;
    8024             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8025           0 :   void *argp1 = 0 ;
    8026             :   int res1 = 0 ;
    8027           0 :   PyObject * obj0 = 0 ;
    8028             :   bool result;
    8029             :   
    8030           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_IsInternal",&obj0)) SWIG_fail;
    8031           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8032           0 :   if (!SWIG_IsOK(res1)) {
    8033           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_IsInternal" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8034             :   }
    8035           0 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8036             :   {
    8037             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8038           0 :     result = (bool)(arg1)->IsInternal();
    8039             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8040             :   }
    8041             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8042           0 :   return resultobj;
    8043             : fail:
    8044             :   return NULL;
    8045             : }
    8046             : 
    8047             : 
    8048           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetHitCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8049             :   PyObject *resultobj = 0;
    8050             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8051           2 :   void *argp1 = 0 ;
    8052             :   int res1 = 0 ;
    8053           2 :   PyObject * obj0 = 0 ;
    8054             :   uint32_t result;
    8055             :   
    8056           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetHitCount",&obj0)) SWIG_fail;
    8057           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8058           2 :   if (!SWIG_IsOK(res1)) {
    8059           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetHitCount" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8060             :   }
    8061           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8062             :   {
    8063             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8064           2 :     result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetHitCount();
    8065             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8066             :   }
    8067             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    8068           2 :   return resultobj;
    8069             : fail:
    8070             :   return NULL;
    8071             : }
    8072             : 
    8073             : 
    8074           8 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetIgnoreCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8075             :   PyObject *resultobj = 0;
    8076             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8077             :   uint32_t arg2 ;
    8078           8 :   void *argp1 = 0 ;
    8079             :   int res1 = 0 ;
    8080             :   unsigned int val2 ;
    8081             :   int ecode2 = 0 ;
    8082           8 :   PyObject * obj0 = 0 ;
    8083           8 :   PyObject * obj1 = 0 ;
    8084             :   
    8085           8 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetIgnoreCount",&obj0,&obj1)) SWIG_fail;
    8086           8 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8087           8 :   if (!SWIG_IsOK(res1)) {
    8088           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8089             :   }
    8090           8 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8091           8 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    8092           8 :   if (!SWIG_IsOK(ecode2)) {
    8093           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetIgnoreCount" "', argument " "2"" of type '" "uint32_t""'");
    8094             :   } 
    8095             :   arg2 = static_cast< uint32_t >(val2);
    8096             :   {
    8097             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8098           8 :     (arg1)->SetIgnoreCount(arg2);
    8099             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8100             :   }
    8101             :   resultobj = SWIG_Py_Void();
    8102           8 :   return resultobj;
    8103             : fail:
    8104             :   return NULL;
    8105             : }
    8106             : 
    8107             : 
    8108           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetIgnoreCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8109             :   PyObject *resultobj = 0;
    8110             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8111           6 :   void *argp1 = 0 ;
    8112             :   int res1 = 0 ;
    8113           6 :   PyObject * obj0 = 0 ;
    8114             :   uint32_t result;
    8115             :   
    8116           6 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetIgnoreCount",&obj0)) SWIG_fail;
    8117           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8118           6 :   if (!SWIG_IsOK(res1)) {
    8119           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8120             :   }
    8121           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8122             :   {
    8123             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8124           6 :     result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetIgnoreCount();
    8125             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8126             :   }
    8127             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    8128           6 :   return resultobj;
    8129             : fail:
    8130             :   return NULL;
    8131             : }
    8132             : 
    8133             : 
    8134          12 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8135             :   PyObject *resultobj = 0;
    8136             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8137             :   char *arg2 = (char *) 0 ;
    8138          12 :   void *argp1 = 0 ;
    8139             :   int res1 = 0 ;
    8140             :   int res2 ;
    8141          12 :   char *buf2 = 0 ;
    8142          12 :   int alloc2 = 0 ;
    8143          12 :   PyObject * obj0 = 0 ;
    8144          12 :   PyObject * obj1 = 0 ;
    8145             :   
    8146          12 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetCondition",&obj0,&obj1)) SWIG_fail;
    8147          12 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8148          12 :   if (!SWIG_IsOK(res1)) {
    8149           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetCondition" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8150             :   }
    8151          12 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8152          12 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8153          12 :   if (!SWIG_IsOK(res2)) {
    8154           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetCondition" "', argument " "2"" of type '" "char const *""'");
    8155             :   }
    8156          12 :   arg2 = reinterpret_cast< char * >(buf2);
    8157             :   {
    8158             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8159          12 :     (arg1)->SetCondition((char const *)arg2);
    8160             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8161             :   }
    8162             :   resultobj = SWIG_Py_Void();
    8163          12 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8164             :   return resultobj;
    8165           0 : fail:
    8166           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8167             :   return NULL;
    8168             : }
    8169             : 
    8170             : 
    8171          12 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8172             :   PyObject *resultobj = 0;
    8173             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8174          12 :   void *argp1 = 0 ;
    8175             :   int res1 = 0 ;
    8176          12 :   PyObject * obj0 = 0 ;
    8177             :   char *result = 0 ;
    8178             :   
    8179          12 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetCondition",&obj0)) SWIG_fail;
    8180          12 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8181          12 :   if (!SWIG_IsOK(res1)) {
    8182           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetCondition" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8183             :   }
    8184          12 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8185             :   {
    8186             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8187          12 :     result = (char *)(arg1)->GetCondition();
    8188             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8189             :   }
    8190          12 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8191          12 :   return resultobj;
    8192             : fail:
    8193             :   return NULL;
    8194             : }
    8195             : 
    8196             : 
    8197           1 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetAutoContinue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8198             :   PyObject *resultobj = 0;
    8199             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8200             :   bool arg2 ;
    8201           1 :   void *argp1 = 0 ;
    8202             :   int res1 = 0 ;
    8203             :   bool val2 ;
    8204             :   int ecode2 = 0 ;
    8205           1 :   PyObject * obj0 = 0 ;
    8206           1 :   PyObject * obj1 = 0 ;
    8207             :   
    8208           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetAutoContinue",&obj0,&obj1)) SWIG_fail;
    8209           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8210           1 :   if (!SWIG_IsOK(res1)) {
    8211           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8212             :   }
    8213           1 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8214           1 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    8215             :   if (!SWIG_IsOK(ecode2)) {
    8216           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetAutoContinue" "', argument " "2"" of type '" "bool""'");
    8217             :   } 
    8218             :   arg2 = static_cast< bool >(val2);
    8219             :   {
    8220             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8221           1 :     (arg1)->SetAutoContinue(arg2);
    8222             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8223             :   }
    8224             :   resultobj = SWIG_Py_Void();
    8225           1 :   return resultobj;
    8226             : fail:
    8227             :   return NULL;
    8228             : }
    8229             : 
    8230             : 
    8231           3 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetAutoContinue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8232             :   PyObject *resultobj = 0;
    8233             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8234           3 :   void *argp1 = 0 ;
    8235             :   int res1 = 0 ;
    8236           3 :   PyObject * obj0 = 0 ;
    8237             :   bool result;
    8238             :   
    8239           3 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetAutoContinue",&obj0)) SWIG_fail;
    8240           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8241           3 :   if (!SWIG_IsOK(res1)) {
    8242           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8243             :   }
    8244           3 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8245             :   {
    8246             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8247           3 :     result = (bool)(arg1)->GetAutoContinue();
    8248             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8249             :   }
    8250             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8251           3 :   return resultobj;
    8252             : fail:
    8253             :   return NULL;
    8254             : }
    8255             : 
    8256             : 
    8257           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8258             :   PyObject *resultobj = 0;
    8259             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8260             :   lldb::tid_t arg2 ;
    8261           6 :   void *argp1 = 0 ;
    8262             :   int res1 = 0 ;
    8263           6 :   PyObject * obj0 = 0 ;
    8264           6 :   PyObject * obj1 = 0 ;
    8265             :   
    8266           6 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetThreadID",&obj0,&obj1)) SWIG_fail;
    8267           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8268           6 :   if (!SWIG_IsOK(res1)) {
    8269           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8270             :   }
    8271           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8272             :   {
    8273             :     using namespace lldb_private;
    8274           6 :     if (PythonInteger::Check(obj1))
    8275             :     {
    8276           6 :       PythonInteger py_int(PyRefType::Borrowed, obj1);
    8277           6 :       arg2 = static_cast<lldb::tid_t>(py_int.GetInteger());
    8278             :     }
    8279             :     else
    8280             :     {
    8281           0 :       PyErr_SetString(PyExc_ValueError, "Expecting an integer");
    8282           0 :       return nullptr;
    8283             :     }
    8284             :   }
    8285             :   {
    8286             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8287           6 :     (arg1)->SetThreadID(arg2);
    8288             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8289             :   }
    8290             :   resultobj = SWIG_Py_Void();
    8291           6 :   return resultobj;
    8292             : fail:
    8293             :   return NULL;
    8294             : }
    8295             : 
    8296             : 
    8297           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8298             :   PyObject *resultobj = 0;
    8299             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8300           4 :   void *argp1 = 0 ;
    8301             :   int res1 = 0 ;
    8302           4 :   PyObject * obj0 = 0 ;
    8303             :   lldb::tid_t result;
    8304             :   
    8305           4 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetThreadID",&obj0)) SWIG_fail;
    8306           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8307           4 :   if (!SWIG_IsOK(res1)) {
    8308           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8309             :   }
    8310           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8311             :   {
    8312             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8313           4 :     result = (lldb::tid_t)(arg1)->GetThreadID();
    8314             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8315             :   }
    8316           4 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    8317           4 :   return resultobj;
    8318             : fail:
    8319             :   return NULL;
    8320             : }
    8321             : 
    8322             : 
    8323           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8324             :   PyObject *resultobj = 0;
    8325             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8326             :   uint32_t arg2 ;
    8327           4 :   void *argp1 = 0 ;
    8328             :   int res1 = 0 ;
    8329             :   unsigned int val2 ;
    8330             :   int ecode2 = 0 ;
    8331           4 :   PyObject * obj0 = 0 ;
    8332           4 :   PyObject * obj1 = 0 ;
    8333             :   
    8334           4 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetThreadIndex",&obj0,&obj1)) SWIG_fail;
    8335           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8336           4 :   if (!SWIG_IsOK(res1)) {
    8337           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8338             :   }
    8339           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8340           4 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    8341           4 :   if (!SWIG_IsOK(ecode2)) {
    8342           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_SetThreadIndex" "', argument " "2"" of type '" "uint32_t""'");
    8343             :   } 
    8344             :   arg2 = static_cast< uint32_t >(val2);
    8345             :   {
    8346             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8347           4 :     (arg1)->SetThreadIndex(arg2);
    8348             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8349             :   }
    8350             :   resultobj = SWIG_Py_Void();
    8351           4 :   return resultobj;
    8352             : fail:
    8353             :   return NULL;
    8354             : }
    8355             : 
    8356             : 
    8357           8 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8358             :   PyObject *resultobj = 0;
    8359             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8360           8 :   void *argp1 = 0 ;
    8361             :   int res1 = 0 ;
    8362           8 :   PyObject * obj0 = 0 ;
    8363             :   uint32_t result;
    8364             :   
    8365           8 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetThreadIndex",&obj0)) SWIG_fail;
    8366           8 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8367           8 :   if (!SWIG_IsOK(res1)) {
    8368           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8369             :   }
    8370           8 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8371             :   {
    8372             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8373           8 :     result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetThreadIndex();
    8374             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8375             :   }
    8376             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    8377           8 :   return resultobj;
    8378             : fail:
    8379             :   return NULL;
    8380             : }
    8381             : 
    8382             : 
    8383           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetThreadName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8384             :   PyObject *resultobj = 0;
    8385             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8386             :   char *arg2 = (char *) 0 ;
    8387           6 :   void *argp1 = 0 ;
    8388             :   int res1 = 0 ;
    8389             :   int res2 ;
    8390           6 :   char *buf2 = 0 ;
    8391           6 :   int alloc2 = 0 ;
    8392           6 :   PyObject * obj0 = 0 ;
    8393           6 :   PyObject * obj1 = 0 ;
    8394             :   
    8395           6 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetThreadName",&obj0,&obj1)) SWIG_fail;
    8396           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8397           6 :   if (!SWIG_IsOK(res1)) {
    8398           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetThreadName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8399             :   }
    8400           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8401           6 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8402           6 :   if (!SWIG_IsOK(res2)) {
    8403           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetThreadName" "', argument " "2"" of type '" "char const *""'");
    8404             :   }
    8405           6 :   arg2 = reinterpret_cast< char * >(buf2);
    8406             :   {
    8407             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8408           6 :     (arg1)->SetThreadName((char const *)arg2);
    8409             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8410             :   }
    8411             :   resultobj = SWIG_Py_Void();
    8412           6 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8413             :   return resultobj;
    8414           0 : fail:
    8415           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8416             :   return NULL;
    8417             : }
    8418             : 
    8419             : 
    8420           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetThreadName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8421             :   PyObject *resultobj = 0;
    8422             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8423           6 :   void *argp1 = 0 ;
    8424             :   int res1 = 0 ;
    8425           6 :   PyObject * obj0 = 0 ;
    8426             :   char *result = 0 ;
    8427             :   
    8428           6 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetThreadName",&obj0)) SWIG_fail;
    8429           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8430           6 :   if (!SWIG_IsOK(res1)) {
    8431           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetThreadName" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8432             :   }
    8433           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8434             :   {
    8435             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8436           6 :     result = (char *)((lldb::SBBreakpoint const *)arg1)->GetThreadName();
    8437             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8438             :   }
    8439           6 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8440           6 :   return resultobj;
    8441             : fail:
    8442             :   return NULL;
    8443             : }
    8444             : 
    8445             : 
    8446           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetQueueName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8447             :   PyObject *resultobj = 0;
    8448             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8449             :   char *arg2 = (char *) 0 ;
    8450           6 :   void *argp1 = 0 ;
    8451             :   int res1 = 0 ;
    8452             :   int res2 ;
    8453           6 :   char *buf2 = 0 ;
    8454           6 :   int alloc2 = 0 ;
    8455           6 :   PyObject * obj0 = 0 ;
    8456           6 :   PyObject * obj1 = 0 ;
    8457             :   
    8458           6 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetQueueName",&obj0,&obj1)) SWIG_fail;
    8459           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8460           6 :   if (!SWIG_IsOK(res1)) {
    8461           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetQueueName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8462             :   }
    8463           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8464           6 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8465           6 :   if (!SWIG_IsOK(res2)) {
    8466           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetQueueName" "', argument " "2"" of type '" "char const *""'");
    8467             :   }
    8468           6 :   arg2 = reinterpret_cast< char * >(buf2);
    8469             :   {
    8470             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8471           6 :     (arg1)->SetQueueName((char const *)arg2);
    8472             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8473             :   }
    8474             :   resultobj = SWIG_Py_Void();
    8475           6 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8476             :   return resultobj;
    8477           0 : fail:
    8478           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8479             :   return NULL;
    8480             : }
    8481             : 
    8482             : 
    8483           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetQueueName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8484             :   PyObject *resultobj = 0;
    8485             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8486           4 :   void *argp1 = 0 ;
    8487             :   int res1 = 0 ;
    8488           4 :   PyObject * obj0 = 0 ;
    8489             :   char *result = 0 ;
    8490             :   
    8491           4 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetQueueName",&obj0)) SWIG_fail;
    8492           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8493           4 :   if (!SWIG_IsOK(res1)) {
    8494           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetQueueName" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8495             :   }
    8496           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8497             :   {
    8498             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8499           4 :     result = (char *)((lldb::SBBreakpoint const *)arg1)->GetQueueName();
    8500             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8501             :   }
    8502           4 :   resultobj = SWIG_FromCharPtr((const char *)result);
    8503           4 :   return resultobj;
    8504             : fail:
    8505             :   return NULL;
    8506             : }
    8507             : 
    8508             : 
    8509           3 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8510             :   PyObject *resultobj = 0;
    8511             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8512             :   char *arg2 = (char *) 0 ;
    8513           3 :   void *argp1 = 0 ;
    8514             :   int res1 = 0 ;
    8515             :   int res2 ;
    8516           3 :   char *buf2 = 0 ;
    8517           3 :   int alloc2 = 0 ;
    8518           3 :   PyObject * obj0 = 0 ;
    8519           3 :   PyObject * obj1 = 0 ;
    8520             :   
    8521           3 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetScriptCallbackFunction",&obj0,&obj1)) SWIG_fail;
    8522           3 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8523           3 :   if (!SWIG_IsOK(res1)) {
    8524           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetScriptCallbackFunction" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8525             :   }
    8526           3 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8527           3 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8528           3 :   if (!SWIG_IsOK(res2)) {
    8529           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetScriptCallbackFunction" "', argument " "2"" of type '" "char const *""'");
    8530             :   }
    8531           3 :   arg2 = reinterpret_cast< char * >(buf2);
    8532             :   {
    8533             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8534           3 :     (arg1)->SetScriptCallbackFunction((char const *)arg2);
    8535             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8536             :   }
    8537             :   resultobj = SWIG_Py_Void();
    8538           3 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8539             :   return resultobj;
    8540           0 : fail:
    8541           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8542             :   return NULL;
    8543             : }
    8544             : 
    8545             : 
    8546           5 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetScriptCallbackBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8547             :   PyObject *resultobj = 0;
    8548             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8549             :   char *arg2 = (char *) 0 ;
    8550           5 :   void *argp1 = 0 ;
    8551             :   int res1 = 0 ;
    8552             :   int res2 ;
    8553           5 :   char *buf2 = 0 ;
    8554           5 :   int alloc2 = 0 ;
    8555           5 :   PyObject * obj0 = 0 ;
    8556           5 :   PyObject * obj1 = 0 ;
    8557          10 :   lldb::SBError result;
    8558             :   
    8559           5 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetScriptCallbackBody",&obj0,&obj1)) SWIG_fail;
    8560           5 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8561           5 :   if (!SWIG_IsOK(res1)) {
    8562           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetScriptCallbackBody" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8563             :   }
    8564           5 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8565           5 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8566           5 :   if (!SWIG_IsOK(res2)) {
    8567           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetScriptCallbackBody" "', argument " "2"" of type '" "char const *""'");
    8568             :   }
    8569           5 :   arg2 = reinterpret_cast< char * >(buf2);
    8570             :   {
    8571             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8572           5 :     result = (arg1)->SetScriptCallbackBody((char const *)arg2);
    8573             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8574             :   }
    8575           5 :   resultobj = SWIG_NewPointerObj((new lldb::SBError(static_cast< const lldb::SBError& >(result))), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
    8576           5 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8577             :   return resultobj;
    8578           0 : fail:
    8579           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8580             :   return NULL;
    8581             : }
    8582             : 
    8583             : 
    8584           4 : SWIGINTERN PyObject *_wrap_SBBreakpoint_SetCommandLineCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8585             :   PyObject *resultobj = 0;
    8586             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8587             :   lldb::SBStringList *arg2 = 0 ;
    8588           4 :   void *argp1 = 0 ;
    8589             :   int res1 = 0 ;
    8590           4 :   void *argp2 = 0 ;
    8591             :   int res2 = 0 ;
    8592           4 :   PyObject * obj0 = 0 ;
    8593           4 :   PyObject * obj1 = 0 ;
    8594             :   
    8595           4 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_SetCommandLineCommands",&obj0,&obj1)) SWIG_fail;
    8596           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8597           4 :   if (!SWIG_IsOK(res1)) {
    8598           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_SetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8599             :   }
    8600           4 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8601           4 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
    8602           4 :   if (!SWIG_IsOK(res2)) {
    8603           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8604             :   }
    8605           4 :   if (!argp2) {
    8606           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8607             :   }
    8608             :   arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
    8609             :   {
    8610             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8611           4 :     (arg1)->SetCommandLineCommands(*arg2);
    8612             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8613             :   }
    8614             :   resultobj = SWIG_Py_Void();
    8615           4 :   return resultobj;
    8616             : fail:
    8617             :   return NULL;
    8618             : }
    8619             : 
    8620             : 
    8621           5 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetCommandLineCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8622             :   PyObject *resultobj = 0;
    8623             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8624             :   lldb::SBStringList *arg2 = 0 ;
    8625           5 :   void *argp1 = 0 ;
    8626             :   int res1 = 0 ;
    8627           5 :   void *argp2 = 0 ;
    8628             :   int res2 = 0 ;
    8629           5 :   PyObject * obj0 = 0 ;
    8630           5 :   PyObject * obj1 = 0 ;
    8631             :   bool result;
    8632             :   
    8633           5 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_GetCommandLineCommands",&obj0,&obj1)) SWIG_fail;
    8634           5 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8635           5 :   if (!SWIG_IsOK(res1)) {
    8636           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8637             :   }
    8638           5 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8639           5 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
    8640           5 :   if (!SWIG_IsOK(res2)) {
    8641           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8642             :   }
    8643           5 :   if (!argp2) {
    8644           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8645             :   }
    8646             :   arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
    8647             :   {
    8648             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8649           5 :     result = (bool)(arg1)->GetCommandLineCommands(*arg2);
    8650             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8651             :   }
    8652             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8653           5 :   return resultobj;
    8654             : fail:
    8655             :   return NULL;
    8656             : }
    8657             : 
    8658             : 
    8659          21 : SWIGINTERN PyObject *_wrap_SBBreakpoint_AddName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8660             :   PyObject *resultobj = 0;
    8661             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8662             :   char *arg2 = (char *) 0 ;
    8663          21 :   void *argp1 = 0 ;
    8664             :   int res1 = 0 ;
    8665             :   int res2 ;
    8666          21 :   char *buf2 = 0 ;
    8667          21 :   int alloc2 = 0 ;
    8668          21 :   PyObject * obj0 = 0 ;
    8669          21 :   PyObject * obj1 = 0 ;
    8670             :   bool result;
    8671             :   
    8672          21 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_AddName",&obj0,&obj1)) SWIG_fail;
    8673          21 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8674          21 :   if (!SWIG_IsOK(res1)) {
    8675           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_AddName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8676             :   }
    8677          21 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8678          21 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8679          21 :   if (!SWIG_IsOK(res2)) {
    8680           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_AddName" "', argument " "2"" of type '" "char const *""'");
    8681             :   }
    8682          21 :   arg2 = reinterpret_cast< char * >(buf2);
    8683             :   {
    8684             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8685          21 :     result = (bool)(arg1)->AddName((char const *)arg2);
    8686             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8687             :   }
    8688             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8689          21 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8690             :   return resultobj;
    8691           0 : fail:
    8692           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8693             :   return NULL;
    8694             : }
    8695             : 
    8696             : 
    8697           1 : SWIGINTERN PyObject *_wrap_SBBreakpoint_RemoveName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8698             :   PyObject *resultobj = 0;
    8699             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8700             :   char *arg2 = (char *) 0 ;
    8701           1 :   void *argp1 = 0 ;
    8702             :   int res1 = 0 ;
    8703             :   int res2 ;
    8704           1 :   char *buf2 = 0 ;
    8705           1 :   int alloc2 = 0 ;
    8706           1 :   PyObject * obj0 = 0 ;
    8707           1 :   PyObject * obj1 = 0 ;
    8708             :   
    8709           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_RemoveName",&obj0,&obj1)) SWIG_fail;
    8710           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8711           1 :   if (!SWIG_IsOK(res1)) {
    8712           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_RemoveName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8713             :   }
    8714           1 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8715           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8716           1 :   if (!SWIG_IsOK(res2)) {
    8717           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_RemoveName" "', argument " "2"" of type '" "char const *""'");
    8718             :   }
    8719           1 :   arg2 = reinterpret_cast< char * >(buf2);
    8720             :   {
    8721             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8722           1 :     (arg1)->RemoveName((char const *)arg2);
    8723             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8724             :   }
    8725             :   resultobj = SWIG_Py_Void();
    8726           1 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8727             :   return resultobj;
    8728           0 : fail:
    8729           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8730             :   return NULL;
    8731             : }
    8732             : 
    8733             : 
    8734           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint_MatchesName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8735             :   PyObject *resultobj = 0;
    8736             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8737             :   char *arg2 = (char *) 0 ;
    8738           6 :   void *argp1 = 0 ;
    8739             :   int res1 = 0 ;
    8740             :   int res2 ;
    8741           6 :   char *buf2 = 0 ;
    8742           6 :   int alloc2 = 0 ;
    8743           6 :   PyObject * obj0 = 0 ;
    8744           6 :   PyObject * obj1 = 0 ;
    8745             :   bool result;
    8746             :   
    8747           6 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_MatchesName",&obj0,&obj1)) SWIG_fail;
    8748           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8749           6 :   if (!SWIG_IsOK(res1)) {
    8750           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_MatchesName" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8751             :   }
    8752           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8753           6 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    8754           6 :   if (!SWIG_IsOK(res2)) {
    8755           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_MatchesName" "', argument " "2"" of type '" "char const *""'");
    8756             :   }
    8757           6 :   arg2 = reinterpret_cast< char * >(buf2);
    8758             :   {
    8759             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8760           6 :     result = (bool)(arg1)->MatchesName((char const *)arg2);
    8761             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8762             :   }
    8763             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8764           6 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8765             :   return resultobj;
    8766           0 : fail:
    8767           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    8768             :   return NULL;
    8769             : }
    8770             : 
    8771             : 
    8772           1 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNames(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8773             :   PyObject *resultobj = 0;
    8774             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8775             :   lldb::SBStringList *arg2 = 0 ;
    8776           1 :   void *argp1 = 0 ;
    8777             :   int res1 = 0 ;
    8778           1 :   void *argp2 = 0 ;
    8779             :   int res2 = 0 ;
    8780           1 :   PyObject * obj0 = 0 ;
    8781           1 :   PyObject * obj1 = 0 ;
    8782             :   
    8783           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_GetNames",&obj0,&obj1)) SWIG_fail;
    8784           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8785           1 :   if (!SWIG_IsOK(res1)) {
    8786           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNames" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8787             :   }
    8788           1 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8789           1 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
    8790           1 :   if (!SWIG_IsOK(res2)) {
    8791           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetNames" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8792             :   }
    8793           1 :   if (!argp2) {
    8794           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetNames" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
    8795             :   }
    8796             :   arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
    8797             :   {
    8798             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8799           1 :     (arg1)->GetNames(*arg2);
    8800             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8801             :   }
    8802             :   resultobj = SWIG_Py_Void();
    8803           1 :   return resultobj;
    8804             : fail:
    8805             :   return NULL;
    8806             : }
    8807             : 
    8808             : 
    8809           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumResolvedLocations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8810             :   PyObject *resultobj = 0;
    8811             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8812           2 :   void *argp1 = 0 ;
    8813             :   int res1 = 0 ;
    8814           2 :   PyObject * obj0 = 0 ;
    8815             :   size_t result;
    8816             :   
    8817           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetNumResolvedLocations",&obj0)) SWIG_fail;
    8818           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8819           2 :   if (!SWIG_IsOK(res1)) {
    8820           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNumResolvedLocations" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8821             :   }
    8822           2 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8823             :   {
    8824             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8825           2 :     result = ((lldb::SBBreakpoint const *)arg1)->GetNumResolvedLocations();
    8826             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8827             :   }
    8828             :   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
    8829           2 :   return resultobj;
    8830             : fail:
    8831             :   return NULL;
    8832             : }
    8833             : 
    8834             : 
    8835         345 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumLocations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8836             :   PyObject *resultobj = 0;
    8837             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8838         345 :   void *argp1 = 0 ;
    8839             :   int res1 = 0 ;
    8840         345 :   PyObject * obj0 = 0 ;
    8841             :   size_t result;
    8842             :   
    8843         345 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetNumLocations",&obj0)) SWIG_fail;
    8844         345 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8845         345 :   if (!SWIG_IsOK(res1)) {
    8846           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNumLocations" "', argument " "1"" of type '" "lldb::SBBreakpoint const *""'"); 
    8847             :   }
    8848         345 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8849             :   {
    8850             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8851         345 :     result = ((lldb::SBBreakpoint const *)arg1)->GetNumLocations();
    8852             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8853             :   }
    8854             :   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
    8855         345 :   return resultobj;
    8856             : fail:
    8857             :   return NULL;
    8858             : }
    8859             : 
    8860             : 
    8861           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8862             :   PyObject *resultobj = 0;
    8863             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8864             :   lldb::SBStream *arg2 = 0 ;
    8865           0 :   void *argp1 = 0 ;
    8866             :   int res1 = 0 ;
    8867           0 :   void *argp2 = 0 ;
    8868             :   int res2 = 0 ;
    8869           0 :   PyObject * obj0 = 0 ;
    8870           0 :   PyObject * obj1 = 0 ;
    8871             :   bool result;
    8872             :   
    8873           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_GetDescription",&obj0,&obj1)) SWIG_fail;
    8874           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8875           0 :   if (!SWIG_IsOK(res1)) {
    8876           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetDescription" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8877             :   }
    8878           0 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8879           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
    8880           0 :   if (!SWIG_IsOK(res2)) {
    8881           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    8882             :   }
    8883           0 :   if (!argp2) {
    8884           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    8885             :   }
    8886             :   arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
    8887             :   {
    8888             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8889           0 :     result = (bool)(arg1)->GetDescription(*arg2);
    8890             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8891             :   }
    8892             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8893           0 :   return resultobj;
    8894             : fail:
    8895             :   return NULL;
    8896             : }
    8897             : 
    8898             : 
    8899           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    8900             :   PyObject *resultobj = 0;
    8901             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    8902             :   lldb::SBStream *arg2 = 0 ;
    8903             :   bool arg3 ;
    8904           0 :   void *argp1 = 0 ;
    8905             :   int res1 = 0 ;
    8906           0 :   void *argp2 = 0 ;
    8907             :   int res2 = 0 ;
    8908             :   bool val3 ;
    8909             :   int ecode3 = 0 ;
    8910           0 :   PyObject * obj0 = 0 ;
    8911           0 :   PyObject * obj1 = 0 ;
    8912           0 :   PyObject * obj2 = 0 ;
    8913             :   bool result;
    8914             :   
    8915           0 :   if (!PyArg_ParseTuple(args,(char *)"OOO:SBBreakpoint_GetDescription",&obj0,&obj1,&obj2)) SWIG_fail;
    8916           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    8917           0 :   if (!SWIG_IsOK(res1)) {
    8918           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetDescription" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    8919             :   }
    8920           0 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    8921           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStream,  0 );
    8922           0 :   if (!SWIG_IsOK(res2)) {
    8923           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    8924             :   }
    8925           0 :   if (!argp2) {
    8926           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetDescription" "', argument " "2"" of type '" "lldb::SBStream &""'"); 
    8927             :   }
    8928             :   arg2 = reinterpret_cast< lldb::SBStream * >(argp2);
    8929           0 :   ecode3 = SWIG_AsVal_bool(obj2, &val3);
    8930             :   if (!SWIG_IsOK(ecode3)) {
    8931           0 :     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SBBreakpoint_GetDescription" "', argument " "3"" of type '" "bool""'");
    8932             :   } 
    8933             :   arg3 = static_cast< bool >(val3);
    8934             :   {
    8935             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    8936           0 :     result = (bool)(arg1)->GetDescription(*arg2,arg3);
    8937             :     SWIG_PYTHON_THREAD_END_ALLOW;
    8938             :   }
    8939             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    8940           0 :   return resultobj;
    8941             : fail:
    8942             :   return NULL;
    8943             : }
    8944             : 
    8945             : 
    8946          62 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetDescription(PyObject *self, PyObject *args) {
    8947             :   Py_ssize_t argc;
    8948          62 :   PyObject *argv[4] = {
    8949             :     0
    8950             :   };
    8951             :   Py_ssize_t ii;
    8952             :   
    8953          62 :   if (!PyTuple_Check(args)) SWIG_fail;
    8954          62 :   argc = args ? PyObject_Length(args) : 0;
    8955         246 :   for (ii = 0; (ii < 3) && (ii < argc); ii++) {
    8956         184 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    8957             :   }
    8958          62 :   if (argc == 2) {
    8959             :     int _v;
    8960           2 :     void *vptr = 0;
    8961           2 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpoint, 0);
    8962           2 :     _v = SWIG_CheckState(res);
    8963             :     if (_v) {
    8964           2 :       void *vptr = 0;
    8965           2 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, 0);
    8966           2 :       _v = SWIG_CheckState(res);
    8967             :       if (_v) {
    8968           2 :         return _wrap_SBBreakpoint_GetDescription__SWIG_0(self, args);
    8969             :       }
    8970             :     }
    8971             :   }
    8972          60 :   if (argc == 3) {
    8973             :     int _v;
    8974          60 :     void *vptr = 0;
    8975          60 :     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_lldb__SBBreakpoint, 0);
    8976          60 :     _v = SWIG_CheckState(res);
    8977             :     if (_v) {
    8978          60 :       void *vptr = 0;
    8979          60 :       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_lldb__SBStream, 0);
    8980          60 :       _v = SWIG_CheckState(res);
    8981             :       if (_v) {
    8982             :         {
    8983          60 :           int res = SWIG_AsVal_bool(argv[2], NULL);
    8984             :           _v = SWIG_CheckState(res);
    8985             :         }
    8986             :         if (_v) {
    8987          60 :           return _wrap_SBBreakpoint_GetDescription__SWIG_1(self, args);
    8988             :         }
    8989             :       }
    8990             :     }
    8991             :   }
    8992             :   
    8993           0 : fail:
    8994           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'SBBreakpoint_GetDescription'.\n"
    8995             :     "  Possible C/C++ prototypes are:\n"
    8996             :     "    lldb::SBBreakpoint::GetDescription(lldb::SBStream &)\n"
    8997             :     "    lldb::SBBreakpoint::GetDescription(lldb::SBStream &,bool)\n");
    8998           0 :   return 0;
    8999             : }
    9000             : 
    9001             : 
    9002          11 : SWIGINTERN PyObject *_wrap_SBBreakpoint_AddLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9003             :   PyObject *resultobj = 0;
    9004             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    9005             :   lldb::SBAddress *arg2 = 0 ;
    9006          11 :   void *argp1 = 0 ;
    9007             :   int res1 = 0 ;
    9008          11 :   void *argp2 = 0 ;
    9009             :   int res2 = 0 ;
    9010          11 :   PyObject * obj0 = 0 ;
    9011          11 :   PyObject * obj1 = 0 ;
    9012          22 :   lldb::SBError result;
    9013             :   
    9014          11 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_AddLocation",&obj0,&obj1)) SWIG_fail;
    9015          11 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    9016          11 :   if (!SWIG_IsOK(res1)) {
    9017           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_AddLocation" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    9018             :   }
    9019          11 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    9020          11 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBAddress,  0 );
    9021          11 :   if (!SWIG_IsOK(res2)) {
    9022           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint_AddLocation" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
    9023             :   }
    9024          11 :   if (!argp2) {
    9025           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_AddLocation" "', argument " "2"" of type '" "lldb::SBAddress &""'"); 
    9026             :   }
    9027             :   arg2 = reinterpret_cast< lldb::SBAddress * >(argp2);
    9028             :   {
    9029             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9030          11 :     result = (arg1)->AddLocation(*arg2);
    9031             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9032             :   }
    9033          11 :   resultobj = SWIG_NewPointerObj((new lldb::SBError(static_cast< const lldb::SBError& >(result))), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
    9034          11 :   return resultobj;
    9035             : fail:
    9036             :   return NULL;
    9037             : }
    9038             : 
    9039             : 
    9040           6 : SWIGINTERN PyObject *_wrap_SBBreakpoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9041             :   PyObject *resultobj = 0;
    9042             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    9043             :   lldb::SBBreakpoint *arg2 = 0 ;
    9044           6 :   void *argp1 = 0 ;
    9045             :   int res1 = 0 ;
    9046           6 :   void *argp2 = 0 ;
    9047             :   int res2 = 0 ;
    9048           6 :   PyObject * obj0 = 0 ;
    9049           6 :   PyObject * obj1 = 0 ;
    9050             :   bool result;
    9051             :   
    9052           6 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint___eq__",&obj0,&obj1)) SWIG_fail;
    9053           6 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    9054           6 :   if (!SWIG_IsOK(res1)) {
    9055           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint___eq__" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    9056             :   }
    9057           6 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    9058           6 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
    9059           6 :   if (!SWIG_IsOK(res2)) {
    9060           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint___eq__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9061             :   }
    9062           6 :   if (!argp2) {
    9063           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint___eq__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9064             :   }
    9065             :   arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
    9066             :   {
    9067             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9068           6 :     result = (bool)(arg1)->operator ==((lldb::SBBreakpoint const &)*arg2);
    9069             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9070             :   }
    9071             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9072           6 :   return resultobj;
    9073             : fail:
    9074             :   return NULL;
    9075             : }
    9076             : 
    9077             : 
    9078           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9079             :   PyObject *resultobj = 0;
    9080             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    9081             :   lldb::SBBreakpoint *arg2 = 0 ;
    9082           0 :   void *argp1 = 0 ;
    9083             :   int res1 = 0 ;
    9084           0 :   void *argp2 = 0 ;
    9085             :   int res2 = 0 ;
    9086           0 :   PyObject * obj0 = 0 ;
    9087           0 :   PyObject * obj1 = 0 ;
    9088             :   bool result;
    9089             :   
    9090           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint___ne__",&obj0,&obj1)) SWIG_fail;
    9091           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    9092           0 :   if (!SWIG_IsOK(res1)) {
    9093           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint___ne__" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    9094             :   }
    9095           0 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    9096           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
    9097           0 :   if (!SWIG_IsOK(res2)) {
    9098           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpoint___ne__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9099             :   }
    9100           0 :   if (!argp2) {
    9101           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint___ne__" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9102             :   }
    9103             :   arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
    9104             :   {
    9105             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9106           0 :     result = (bool)(arg1)->operator !=((lldb::SBBreakpoint const &)*arg2);
    9107             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9108             :   }
    9109             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9110           0 :   return resultobj;
    9111             : fail:
    9112             :   return NULL;
    9113             : }
    9114             : 
    9115             : 
    9116           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_EventIsBreakpointEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9117             :   PyObject *resultobj = 0;
    9118             :   lldb::SBEvent *arg1 = 0 ;
    9119           2 :   void *argp1 = 0 ;
    9120             :   int res1 = 0 ;
    9121           2 :   PyObject * obj0 = 0 ;
    9122             :   bool result;
    9123             :   
    9124           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_EventIsBreakpointEvent",&obj0)) SWIG_fail;
    9125           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
    9126           2 :   if (!SWIG_IsOK(res1)) {
    9127           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_EventIsBreakpointEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9128             :   }
    9129           2 :   if (!argp1) {
    9130           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_EventIsBreakpointEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9131             :   }
    9132             :   arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
    9133             :   {
    9134             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9135           2 :     result = (bool)lldb::SBBreakpoint::EventIsBreakpointEvent((lldb::SBEvent const &)*arg1);
    9136             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9137             :   }
    9138             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9139           2 :   return resultobj;
    9140             : fail:
    9141             :   return NULL;
    9142             : }
    9143             : 
    9144             : 
    9145           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetBreakpointEventTypeFromEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9146             :   PyObject *resultobj = 0;
    9147             :   lldb::SBEvent *arg1 = 0 ;
    9148           2 :   void *argp1 = 0 ;
    9149             :   int res1 = 0 ;
    9150           2 :   PyObject * obj0 = 0 ;
    9151             :   lldb::BreakpointEventType result;
    9152             :   
    9153           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetBreakpointEventTypeFromEvent",&obj0)) SWIG_fail;
    9154           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
    9155           2 :   if (!SWIG_IsOK(res1)) {
    9156           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetBreakpointEventTypeFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9157             :   }
    9158           2 :   if (!argp1) {
    9159           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetBreakpointEventTypeFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9160             :   }
    9161             :   arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
    9162             :   {
    9163             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9164           2 :     result = (lldb::BreakpointEventType)lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent((lldb::SBEvent const &)*arg1);
    9165             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9166             :   }
    9167           2 :   resultobj = SWIG_From_int(static_cast< int >(result));
    9168           2 :   return resultobj;
    9169             : fail:
    9170             :   return NULL;
    9171             : }
    9172             : 
    9173             : 
    9174           2 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetBreakpointFromEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9175             :   PyObject *resultobj = 0;
    9176             :   lldb::SBEvent *arg1 = 0 ;
    9177           2 :   void *argp1 = 0 ;
    9178             :   int res1 = 0 ;
    9179           2 :   PyObject * obj0 = 0 ;
    9180           4 :   lldb::SBBreakpoint result;
    9181             :   
    9182           2 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetBreakpointFromEvent",&obj0)) SWIG_fail;
    9183           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
    9184           2 :   if (!SWIG_IsOK(res1)) {
    9185           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetBreakpointFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9186             :   }
    9187           2 :   if (!argp1) {
    9188           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetBreakpointFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9189             :   }
    9190             :   arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
    9191             :   {
    9192             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9193           2 :     result = lldb::SBBreakpoint::GetBreakpointFromEvent((lldb::SBEvent const &)*arg1);
    9194             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9195             :   }
    9196           2 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(static_cast< const lldb::SBBreakpoint& >(result))), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
    9197           2 :   return resultobj;
    9198             : fail:
    9199             :   return NULL;
    9200             : }
    9201             : 
    9202             : 
    9203           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetBreakpointLocationAtIndexFromEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9204             :   PyObject *resultobj = 0;
    9205             :   lldb::SBEvent *arg1 = 0 ;
    9206             :   uint32_t arg2 ;
    9207           0 :   void *argp1 = 0 ;
    9208             :   int res1 = 0 ;
    9209             :   unsigned int val2 ;
    9210             :   int ecode2 = 0 ;
    9211           0 :   PyObject * obj0 = 0 ;
    9212           0 :   PyObject * obj1 = 0 ;
    9213           0 :   lldb::SBBreakpointLocation result;
    9214             :   
    9215           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpoint_GetBreakpointLocationAtIndexFromEvent",&obj0,&obj1)) SWIG_fail;
    9216           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
    9217           0 :   if (!SWIG_IsOK(res1)) {
    9218           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9219             :   }
    9220           0 :   if (!argp1) {
    9221           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9222             :   }
    9223             :   arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
    9224           0 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    9225           0 :   if (!SWIG_IsOK(ecode2)) {
    9226           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent" "', argument " "2"" of type '" "uint32_t""'");
    9227             :   } 
    9228             :   arg2 = static_cast< uint32_t >(val2);
    9229             :   {
    9230             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9231           0 :     result = lldb::SBBreakpoint::GetBreakpointLocationAtIndexFromEvent((lldb::SBEvent const &)*arg1,arg2);
    9232             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9233             :   }
    9234           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpointLocation(static_cast< const lldb::SBBreakpointLocation& >(result))), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_OWN |  0 );
    9235           0 :   return resultobj;
    9236             : fail:
    9237             :   return NULL;
    9238             : }
    9239             : 
    9240             : 
    9241           0 : SWIGINTERN PyObject *_wrap_SBBreakpoint_GetNumBreakpointLocationsFromEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9242             :   PyObject *resultobj = 0;
    9243             :   lldb::SBEvent *arg1 = 0 ;
    9244           0 :   void *argp1 = 0 ;
    9245             :   int res1 = 0 ;
    9246           0 :   PyObject * obj0 = 0 ;
    9247             :   uint32_t result;
    9248             :   
    9249           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint_GetNumBreakpointLocationsFromEvent",&obj0)) SWIG_fail;
    9250           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBEvent,  0  | 0);
    9251           0 :   if (!SWIG_IsOK(res1)) {
    9252           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint_GetNumBreakpointLocationsFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9253             :   }
    9254           0 :   if (!argp1) {
    9255           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpoint_GetNumBreakpointLocationsFromEvent" "', argument " "1"" of type '" "lldb::SBEvent const &""'"); 
    9256             :   }
    9257             :   arg1 = reinterpret_cast< lldb::SBEvent * >(argp1);
    9258             :   {
    9259             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9260           0 :     result = (uint32_t)lldb::SBBreakpoint::GetNumBreakpointLocationsFromEvent((lldb::SBEvent const &)*arg1);
    9261             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9262             :   }
    9263             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    9264           0 :   return resultobj;
    9265             : fail:
    9266             :   return NULL;
    9267             : }
    9268             : 
    9269             : 
    9270           8 : SWIGINTERN PyObject *_wrap_SBBreakpoint___str__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9271             :   PyObject *resultobj = 0;
    9272             :   lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ;
    9273           8 :   void *argp1 = 0 ;
    9274             :   int res1 = 0 ;
    9275           8 :   PyObject * obj0 = 0 ;
    9276             :   PyObject *result = 0 ;
    9277             :   
    9278           8 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpoint___str__",&obj0)) SWIG_fail;
    9279           8 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpoint, 0 |  0 );
    9280           8 :   if (!SWIG_IsOK(res1)) {
    9281           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpoint___str__" "', argument " "1"" of type '" "lldb::SBBreakpoint *""'"); 
    9282             :   }
    9283           8 :   arg1 = reinterpret_cast< lldb::SBBreakpoint * >(argp1);
    9284           8 :   result = (PyObject *)lldb_SBBreakpoint___str__(arg1);
    9285             :   resultobj = result;
    9286           8 :   return resultobj;
    9287             : fail:
    9288             :   return NULL;
    9289             : }
    9290             : 
    9291             : 
    9292         652 : SWIGINTERN PyObject *SBBreakpoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9293             :   PyObject *obj;
    9294         652 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    9295         652 :   SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBreakpoint, SWIG_NewClientData(obj));
    9296         652 :   return SWIG_Py_Void();
    9297             : }
    9298             : 
    9299          29 : SWIGINTERN PyObject *_wrap_new_SBBreakpointList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9300             :   PyObject *resultobj = 0;
    9301             :   lldb::SBTarget *arg1 = 0 ;
    9302          29 :   void *argp1 = 0 ;
    9303             :   int res1 = 0 ;
    9304          29 :   PyObject * obj0 = 0 ;
    9305             :   lldb::SBBreakpointList *result = 0 ;
    9306             :   
    9307          29 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBBreakpointList",&obj0)) SWIG_fail;
    9308          29 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBTarget,  0 );
    9309          29 :   if (!SWIG_IsOK(res1)) {
    9310           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpointList" "', argument " "1"" of type '" "lldb::SBTarget &""'"); 
    9311             :   }
    9312          29 :   if (!argp1) {
    9313           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBBreakpointList" "', argument " "1"" of type '" "lldb::SBTarget &""'"); 
    9314             :   }
    9315             :   arg1 = reinterpret_cast< lldb::SBTarget * >(argp1);
    9316             :   {
    9317             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9318          29 :     result = (lldb::SBBreakpointList *)new lldb::SBBreakpointList(*arg1);
    9319             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9320             :   }
    9321          29 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NEW |  0 );
    9322          29 :   return resultobj;
    9323             : fail:
    9324             :   return NULL;
    9325             : }
    9326             : 
    9327             : 
    9328          29 : SWIGINTERN PyObject *_wrap_delete_SBBreakpointList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9329             :   PyObject *resultobj = 0;
    9330             :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9331          29 :   void *argp1 = 0 ;
    9332             :   int res1 = 0 ;
    9333          29 :   PyObject * obj0 = 0 ;
    9334             :   
    9335          29 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBBreakpointList",&obj0)) SWIG_fail;
    9336          29 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_DISOWN |  0 );
    9337          29 :   if (!SWIG_IsOK(res1)) {
    9338           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBreakpointList" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9339             :   }
    9340          29 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9341             :   {
    9342             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9343          29 :     delete arg1;
    9344             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9345             :   }
    9346             :   resultobj = SWIG_Py_Void();
    9347          29 :   return resultobj;
    9348             : fail:
    9349             :   return NULL;
    9350             : }
    9351             : 
    9352             : 
    9353          33 : SWIGINTERN PyObject *_wrap_SBBreakpointList_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9354             :   PyObject *resultobj = 0;
    9355             :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9356          33 :   void *argp1 = 0 ;
    9357             :   int res1 = 0 ;
    9358          33 :   PyObject * obj0 = 0 ;
    9359             :   size_t result;
    9360             :   
    9361          33 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointList_GetSize",&obj0)) SWIG_fail;
    9362          33 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9363          33 :   if (!SWIG_IsOK(res1)) {
    9364           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_GetSize" "', argument " "1"" of type '" "lldb::SBBreakpointList const *""'"); 
    9365             :   }
    9366          33 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9367             :   {
    9368             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9369          33 :     result = ((lldb::SBBreakpointList const *)arg1)->GetSize();
    9370             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9371             :   }
    9372             :   resultobj = SWIG_From_size_t(static_cast< size_t >(result));
    9373          33 :   return resultobj;
    9374             : fail:
    9375             :   return NULL;
    9376             : }
    9377             : 
    9378             : 
    9379          31 : SWIGINTERN PyObject *_wrap_SBBreakpointList_GetBreakpointAtIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9380             :   PyObject *resultobj = 0;
    9381             :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9382             :   size_t arg2 ;
    9383          31 :   void *argp1 = 0 ;
    9384             :   int res1 = 0 ;
    9385             :   size_t val2 ;
    9386             :   int ecode2 = 0 ;
    9387          31 :   PyObject * obj0 = 0 ;
    9388          31 :   PyObject * obj1 = 0 ;
    9389          62 :   lldb::SBBreakpoint result;
    9390             :   
    9391          31 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointList_GetBreakpointAtIndex",&obj0,&obj1)) SWIG_fail;
    9392          31 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9393          31 :   if (!SWIG_IsOK(res1)) {
    9394           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_GetBreakpointAtIndex" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9395             :   }
    9396          31 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9397          31 :   ecode2 = SWIG_AsVal_size_t(obj1, &val2);
    9398          31 :   if (!SWIG_IsOK(ecode2)) {
    9399           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointList_GetBreakpointAtIndex" "', argument " "2"" of type '" "size_t""'");
    9400             :   } 
    9401             :   arg2 = static_cast< size_t >(val2);
    9402             :   {
    9403             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9404          31 :     result = (arg1)->GetBreakpointAtIndex(arg2);
    9405             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9406             :   }
    9407          31 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(static_cast< const lldb::SBBreakpoint& >(result))), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
    9408          31 :   return resultobj;
    9409             : fail:
    9410             :   return NULL;
    9411             : }
    9412             : 
    9413             : 
    9414          30 : SWIGINTERN PyObject *_wrap_SBBreakpointList_FindBreakpointByID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9415             :   PyObject *resultobj = 0;
    9416             :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9417             :   lldb::break_id_t arg2 ;
    9418          30 :   void *argp1 = 0 ;
    9419             :   int res1 = 0 ;
    9420             :   int val2 ;
    9421             :   int ecode2 = 0 ;
    9422          30 :   PyObject * obj0 = 0 ;
    9423          30 :   PyObject * obj1 = 0 ;
    9424          60 :   lldb::SBBreakpoint result;
    9425             :   
    9426          30 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointList_FindBreakpointByID",&obj0,&obj1)) SWIG_fail;
    9427          30 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9428          30 :   if (!SWIG_IsOK(res1)) {
    9429           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_FindBreakpointByID" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9430             :   }
    9431          30 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9432          30 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    9433          30 :   if (!SWIG_IsOK(ecode2)) {
    9434           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointList_FindBreakpointByID" "', argument " "2"" of type '" "lldb::break_id_t""'");
    9435             :   } 
    9436             :   arg2 = static_cast< lldb::break_id_t >(val2);
    9437             :   {
    9438             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9439          30 :     result = (arg1)->FindBreakpointByID(arg2);
    9440             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9441             :   }
    9442          30 :   resultobj = SWIG_NewPointerObj((new lldb::SBBreakpoint(static_cast< const lldb::SBBreakpoint& >(result))), SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_OWN |  0 );
    9443          30 :   return resultobj;
    9444             : fail:
    9445             :   return NULL;
    9446             : }
    9447             : 
    9448             : 
    9449          38 : SWIGINTERN PyObject *_wrap_SBBreakpointList_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9450             :   PyObject *resultobj = 0;
    9451             :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9452             :   lldb::SBBreakpoint *arg2 = 0 ;
    9453          38 :   void *argp1 = 0 ;
    9454             :   int res1 = 0 ;
    9455          38 :   void *argp2 = 0 ;
    9456             :   int res2 = 0 ;
    9457          38 :   PyObject * obj0 = 0 ;
    9458          38 :   PyObject * obj1 = 0 ;
    9459             :   
    9460          38 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointList_Append",&obj0,&obj1)) SWIG_fail;
    9461          38 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9462          38 :   if (!SWIG_IsOK(res1)) {
    9463           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_Append" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9464             :   }
    9465          38 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9466          38 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
    9467          38 :   if (!SWIG_IsOK(res2)) {
    9468           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointList_Append" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9469             :   }
    9470          38 :   if (!argp2) {
    9471           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpointList_Append" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9472             :   }
    9473             :   arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
    9474             :   {
    9475             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9476          38 :     (arg1)->Append((lldb::SBBreakpoint const &)*arg2);
    9477             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9478             :   }
    9479             :   resultobj = SWIG_Py_Void();
    9480          38 :   return resultobj;
    9481             : fail:
    9482             :   return NULL;
    9483             : }
    9484             : 
    9485             : 
    9486           0 : SWIGINTERN PyObject *_wrap_SBBreakpointList_AppendIfUnique(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9487             :   PyObject *resultobj = 0;
    9488             :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9489             :   lldb::SBBreakpoint *arg2 = 0 ;
    9490           0 :   void *argp1 = 0 ;
    9491             :   int res1 = 0 ;
    9492           0 :   void *argp2 = 0 ;
    9493             :   int res2 = 0 ;
    9494           0 :   PyObject * obj0 = 0 ;
    9495           0 :   PyObject * obj1 = 0 ;
    9496             :   bool result;
    9497             :   
    9498           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointList_AppendIfUnique",&obj0,&obj1)) SWIG_fail;
    9499           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9500           0 :   if (!SWIG_IsOK(res1)) {
    9501           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_AppendIfUnique" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9502             :   }
    9503           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9504           0 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBBreakpoint,  0  | 0);
    9505           0 :   if (!SWIG_IsOK(res2)) {
    9506           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointList_AppendIfUnique" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9507             :   }
    9508           0 :   if (!argp2) {
    9509           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpointList_AppendIfUnique" "', argument " "2"" of type '" "lldb::SBBreakpoint const &""'"); 
    9510             :   }
    9511             :   arg2 = reinterpret_cast< lldb::SBBreakpoint * >(argp2);
    9512             :   {
    9513             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9514           0 :     result = (bool)(arg1)->AppendIfUnique((lldb::SBBreakpoint const &)*arg2);
    9515             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9516             :   }
    9517             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9518           0 :   return resultobj;
    9519             : fail:
    9520             :   return NULL;
    9521             : }
    9522             : 
    9523             : 
    9524           0 : SWIGINTERN PyObject *_wrap_SBBreakpointList_AppendByID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9525             :   PyObject *resultobj = 0;
    9526             :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9527             :   lldb::break_id_t arg2 ;
    9528           0 :   void *argp1 = 0 ;
    9529             :   int res1 = 0 ;
    9530             :   int val2 ;
    9531             :   int ecode2 = 0 ;
    9532           0 :   PyObject * obj0 = 0 ;
    9533           0 :   PyObject * obj1 = 0 ;
    9534             :   
    9535           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointList_AppendByID",&obj0,&obj1)) SWIG_fail;
    9536           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9537           0 :   if (!SWIG_IsOK(res1)) {
    9538           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_AppendByID" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9539             :   }
    9540           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9541           0 :   ecode2 = SWIG_AsVal_int(obj1, &val2);
    9542           0 :   if (!SWIG_IsOK(ecode2)) {
    9543           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointList_AppendByID" "', argument " "2"" of type '" "lldb::break_id_t""'");
    9544             :   } 
    9545             :   arg2 = static_cast< lldb::break_id_t >(val2);
    9546             :   {
    9547             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9548           0 :     (arg1)->AppendByID(arg2);
    9549             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9550             :   }
    9551             :   resultobj = SWIG_Py_Void();
    9552           0 :   return resultobj;
    9553             : fail:
    9554             :   return NULL;
    9555             : }
    9556             : 
    9557             : 
    9558           8 : SWIGINTERN PyObject *_wrap_SBBreakpointList_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9559             :   PyObject *resultobj = 0;
    9560             :   lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ;
    9561           8 :   void *argp1 = 0 ;
    9562             :   int res1 = 0 ;
    9563           8 :   PyObject * obj0 = 0 ;
    9564             :   
    9565           8 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointList_Clear",&obj0)) SWIG_fail;
    9566           8 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointList, 0 |  0 );
    9567           8 :   if (!SWIG_IsOK(res1)) {
    9568           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointList_Clear" "', argument " "1"" of type '" "lldb::SBBreakpointList *""'"); 
    9569             :   }
    9570           8 :   arg1 = reinterpret_cast< lldb::SBBreakpointList * >(argp1);
    9571             :   {
    9572             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9573           8 :     (arg1)->Clear();
    9574             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9575             :   }
    9576             :   resultobj = SWIG_Py_Void();
    9577           8 :   return resultobj;
    9578             : fail:
    9579             :   return NULL;
    9580             : }
    9581             : 
    9582             : 
    9583         652 : SWIGINTERN PyObject *SBBreakpointList_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9584             :   PyObject *obj;
    9585         652 :   if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
    9586         652 :   SWIG_TypeNewClientData(SWIGTYPE_p_lldb__SBBreakpointList, SWIG_NewClientData(obj));
    9587         652 :   return SWIG_Py_Void();
    9588             : }
    9589             : 
    9590           0 : SWIGINTERN PyObject *_wrap_new_SBBreakpointLocation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9591             :   PyObject *resultobj = 0;
    9592             :   lldb::SBBreakpointLocation *result = 0 ;
    9593             :   
    9594           0 :   if (!PyArg_ParseTuple(args,(char *)":new_SBBreakpointLocation")) SWIG_fail;
    9595             :   {
    9596             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9597           0 :     result = (lldb::SBBreakpointLocation *)new lldb::SBBreakpointLocation();
    9598             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9599             :   }
    9600           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_NEW |  0 );
    9601           0 :   return resultobj;
    9602             : fail:
    9603           0 :   return NULL;
    9604             : }
    9605             : 
    9606             : 
    9607           0 : SWIGINTERN PyObject *_wrap_new_SBBreakpointLocation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9608             :   PyObject *resultobj = 0;
    9609             :   lldb::SBBreakpointLocation *arg1 = 0 ;
    9610           0 :   void *argp1 = 0 ;
    9611             :   int res1 = 0 ;
    9612           0 :   PyObject * obj0 = 0 ;
    9613             :   lldb::SBBreakpointLocation *result = 0 ;
    9614             :   
    9615           0 :   if (!PyArg_ParseTuple(args,(char *)"O:new_SBBreakpointLocation",&obj0)) SWIG_fail;
    9616           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_lldb__SBBreakpointLocation,  0  | 0);
    9617           0 :   if (!SWIG_IsOK(res1)) {
    9618           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SBBreakpointLocation" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const &""'"); 
    9619             :   }
    9620           0 :   if (!argp1) {
    9621           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SBBreakpointLocation" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const &""'"); 
    9622             :   }
    9623             :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9624             :   {
    9625             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9626           0 :     result = (lldb::SBBreakpointLocation *)new lldb::SBBreakpointLocation((lldb::SBBreakpointLocation const &)*arg1);
    9627             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9628             :   }
    9629           0 :   resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_NEW |  0 );
    9630           0 :   return resultobj;
    9631             : fail:
    9632             :   return NULL;
    9633             : }
    9634             : 
    9635             : 
    9636           2 : SWIGINTERN PyObject *_wrap_new_SBBreakpointLocation(PyObject *self, PyObject *args) {
    9637             :   Py_ssize_t argc;
    9638           2 :   PyObject *argv[2] = {
    9639             :     0
    9640             :   };
    9641             :   Py_ssize_t ii;
    9642             :   
    9643           2 :   if (!PyTuple_Check(args)) SWIG_fail;
    9644           2 :   argc = args ? PyObject_Length(args) : 0;
    9645           2 :   for (ii = 0; (ii < 1) && (ii < argc); ii++) {
    9646           0 :     argv[ii] = PyTuple_GET_ITEM(args,ii);
    9647             :   }
    9648           2 :   if (argc == 0) {
    9649           2 :     return _wrap_new_SBBreakpointLocation__SWIG_0(self, args);
    9650             :   }
    9651           0 :   if (argc == 1) {
    9652             :     int _v;
    9653           0 :     int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_lldb__SBBreakpointLocation, 0);
    9654           0 :     _v = SWIG_CheckState(res);
    9655             :     if (_v) {
    9656           0 :       return _wrap_new_SBBreakpointLocation__SWIG_1(self, args);
    9657             :     }
    9658             :   }
    9659             :   
    9660           0 : fail:
    9661           0 :   SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_SBBreakpointLocation'.\n"
    9662             :     "  Possible C/C++ prototypes are:\n"
    9663             :     "    lldb::SBBreakpointLocation::SBBreakpointLocation()\n"
    9664             :     "    lldb::SBBreakpointLocation::SBBreakpointLocation(lldb::SBBreakpointLocation const &)\n");
    9665           0 :   return 0;
    9666             : }
    9667             : 
    9668             : 
    9669         143 : SWIGINTERN PyObject *_wrap_delete_SBBreakpointLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9670             :   PyObject *resultobj = 0;
    9671             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9672         143 :   void *argp1 = 0 ;
    9673             :   int res1 = 0 ;
    9674         143 :   PyObject * obj0 = 0 ;
    9675             :   
    9676         143 :   if (!PyArg_ParseTuple(args,(char *)"O:delete_SBBreakpointLocation",&obj0)) SWIG_fail;
    9677         143 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_DISOWN |  0 );
    9678         143 :   if (!SWIG_IsOK(res1)) {
    9679           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SBBreakpointLocation" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9680             :   }
    9681         143 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9682             :   {
    9683             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9684         143 :     delete arg1;
    9685             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9686             :   }
    9687             :   resultobj = SWIG_Py_Void();
    9688         143 :   return resultobj;
    9689             : fail:
    9690             :   return NULL;
    9691             : }
    9692             : 
    9693             : 
    9694           0 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9695             :   PyObject *resultobj = 0;
    9696             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9697           0 :   void *argp1 = 0 ;
    9698             :   int res1 = 0 ;
    9699           0 :   PyObject * obj0 = 0 ;
    9700             :   lldb::break_id_t result;
    9701             :   
    9702           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetID",&obj0)) SWIG_fail;
    9703           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9704           0 :   if (!SWIG_IsOK(res1)) {
    9705           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetID" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9706             :   }
    9707           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9708             :   {
    9709             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9710           0 :     result = (lldb::break_id_t)(arg1)->GetID();
    9711             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9712             :   }
    9713             :   resultobj = SWIG_From_int(static_cast< int >(result));
    9714           0 :   return resultobj;
    9715             : fail:
    9716             :   return NULL;
    9717             : }
    9718             : 
    9719             : 
    9720          15 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsValid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9721             :   PyObject *resultobj = 0;
    9722             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9723          15 :   void *argp1 = 0 ;
    9724             :   int res1 = 0 ;
    9725          15 :   PyObject * obj0 = 0 ;
    9726             :   bool result;
    9727             :   
    9728          15 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_IsValid",&obj0)) SWIG_fail;
    9729          15 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9730          15 :   if (!SWIG_IsOK(res1)) {
    9731           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_IsValid" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const *""'"); 
    9732             :   }
    9733          15 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9734             :   {
    9735             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9736          15 :     result = (bool)((lldb::SBBreakpointLocation const *)arg1)->IsValid();
    9737             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9738             :   }
    9739             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9740          15 :   return resultobj;
    9741             : fail:
    9742             :   return NULL;
    9743             : }
    9744             : 
    9745             : 
    9746          86 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9747             :   PyObject *resultobj = 0;
    9748             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9749          86 :   void *argp1 = 0 ;
    9750             :   int res1 = 0 ;
    9751          86 :   PyObject * obj0 = 0 ;
    9752         172 :   lldb::SBAddress result;
    9753             :   
    9754          86 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetAddress",&obj0)) SWIG_fail;
    9755          86 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9756          86 :   if (!SWIG_IsOK(res1)) {
    9757           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetAddress" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9758             :   }
    9759          86 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9760             :   {
    9761             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9762          86 :     result = (arg1)->GetAddress();
    9763             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9764             :   }
    9765          86 :   resultobj = SWIG_NewPointerObj((new lldb::SBAddress(static_cast< const lldb::SBAddress& >(result))), SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_OWN |  0 );
    9766          86 :   return resultobj;
    9767             : fail:
    9768             :   return NULL;
    9769             : }
    9770             : 
    9771             : 
    9772          13 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetLoadAddress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9773             :   PyObject *resultobj = 0;
    9774             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9775          13 :   void *argp1 = 0 ;
    9776             :   int res1 = 0 ;
    9777          13 :   PyObject * obj0 = 0 ;
    9778             :   lldb::addr_t result;
    9779             :   
    9780          13 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetLoadAddress",&obj0)) SWIG_fail;
    9781          13 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9782          13 :   if (!SWIG_IsOK(res1)) {
    9783           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetLoadAddress" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9784             :   }
    9785          13 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9786             :   {
    9787             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9788          13 :     result = (lldb::addr_t)(arg1)->GetLoadAddress();
    9789             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9790             :   }
    9791          13 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    9792          13 :   return resultobj;
    9793             : fail:
    9794             :   return NULL;
    9795             : }
    9796             : 
    9797             : 
    9798           1 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9799             :   PyObject *resultobj = 0;
    9800             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9801             :   bool arg2 ;
    9802           1 :   void *argp1 = 0 ;
    9803             :   int res1 = 0 ;
    9804             :   bool val2 ;
    9805             :   int ecode2 = 0 ;
    9806           1 :   PyObject * obj0 = 0 ;
    9807           1 :   PyObject * obj1 = 0 ;
    9808             :   
    9809           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetEnabled",&obj0,&obj1)) SWIG_fail;
    9810           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9811           1 :   if (!SWIG_IsOK(res1)) {
    9812           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetEnabled" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9813             :   }
    9814           1 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9815           1 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
    9816             :   if (!SWIG_IsOK(ecode2)) {
    9817           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointLocation_SetEnabled" "', argument " "2"" of type '" "bool""'");
    9818             :   } 
    9819             :   arg2 = static_cast< bool >(val2);
    9820             :   {
    9821             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9822           1 :     (arg1)->SetEnabled(arg2);
    9823             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9824             :   }
    9825             :   resultobj = SWIG_Py_Void();
    9826           1 :   return resultobj;
    9827             : fail:
    9828             :   return NULL;
    9829             : }
    9830             : 
    9831             : 
    9832          10 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9833             :   PyObject *resultobj = 0;
    9834             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9835          10 :   void *argp1 = 0 ;
    9836             :   int res1 = 0 ;
    9837          10 :   PyObject * obj0 = 0 ;
    9838             :   bool result;
    9839             :   
    9840          10 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_IsEnabled",&obj0)) SWIG_fail;
    9841          10 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9842          10 :   if (!SWIG_IsOK(res1)) {
    9843           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_IsEnabled" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9844             :   }
    9845          10 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9846             :   {
    9847             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9848          10 :     result = (bool)(arg1)->IsEnabled();
    9849             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9850             :   }
    9851             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
    9852          10 :   return resultobj;
    9853             : fail:
    9854             :   return NULL;
    9855             : }
    9856             : 
    9857             : 
    9858           0 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetHitCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9859             :   PyObject *resultobj = 0;
    9860             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9861           0 :   void *argp1 = 0 ;
    9862             :   int res1 = 0 ;
    9863           0 :   PyObject * obj0 = 0 ;
    9864             :   uint32_t result;
    9865             :   
    9866           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetHitCount",&obj0)) SWIG_fail;
    9867           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9868           0 :   if (!SWIG_IsOK(res1)) {
    9869           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetHitCount" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9870             :   }
    9871           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9872             :   {
    9873             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9874           0 :     result = (uint32_t)(arg1)->GetHitCount();
    9875             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9876             :   }
    9877             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    9878           0 :   return resultobj;
    9879             : fail:
    9880             :   return NULL;
    9881             : }
    9882             : 
    9883             : 
    9884           4 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetIgnoreCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9885             :   PyObject *resultobj = 0;
    9886             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9887           4 :   void *argp1 = 0 ;
    9888             :   int res1 = 0 ;
    9889           4 :   PyObject * obj0 = 0 ;
    9890             :   uint32_t result;
    9891             :   
    9892           4 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetIgnoreCount",&obj0)) SWIG_fail;
    9893           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9894           4 :   if (!SWIG_IsOK(res1)) {
    9895           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9896             :   }
    9897           4 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9898             :   {
    9899             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9900           4 :     result = (uint32_t)(arg1)->GetIgnoreCount();
    9901             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9902             :   }
    9903             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    9904           4 :   return resultobj;
    9905             : fail:
    9906             :   return NULL;
    9907             : }
    9908             : 
    9909             : 
    9910           2 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetIgnoreCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9911             :   PyObject *resultobj = 0;
    9912             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9913             :   uint32_t arg2 ;
    9914           2 :   void *argp1 = 0 ;
    9915             :   int res1 = 0 ;
    9916             :   unsigned int val2 ;
    9917             :   int ecode2 = 0 ;
    9918           2 :   PyObject * obj0 = 0 ;
    9919           2 :   PyObject * obj1 = 0 ;
    9920             :   
    9921           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetIgnoreCount",&obj0,&obj1)) SWIG_fail;
    9922           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9923           2 :   if (!SWIG_IsOK(res1)) {
    9924           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetIgnoreCount" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9925             :   }
    9926           2 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9927           2 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    9928           2 :   if (!SWIG_IsOK(ecode2)) {
    9929           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointLocation_SetIgnoreCount" "', argument " "2"" of type '" "uint32_t""'");
    9930             :   } 
    9931             :   arg2 = static_cast< uint32_t >(val2);
    9932             :   {
    9933             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9934           2 :     (arg1)->SetIgnoreCount(arg2);
    9935             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9936             :   }
    9937             :   resultobj = SWIG_Py_Void();
    9938           2 :   return resultobj;
    9939             : fail:
    9940             :   return NULL;
    9941             : }
    9942             : 
    9943             : 
    9944          15 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9945             :   PyObject *resultobj = 0;
    9946             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9947             :   char *arg2 = (char *) 0 ;
    9948          15 :   void *argp1 = 0 ;
    9949             :   int res1 = 0 ;
    9950             :   int res2 ;
    9951          15 :   char *buf2 = 0 ;
    9952          15 :   int alloc2 = 0 ;
    9953          15 :   PyObject * obj0 = 0 ;
    9954          15 :   PyObject * obj1 = 0 ;
    9955             :   
    9956          15 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetCondition",&obj0,&obj1)) SWIG_fail;
    9957          15 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9958          15 :   if (!SWIG_IsOK(res1)) {
    9959           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetCondition" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9960             :   }
    9961          15 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9962          15 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    9963          15 :   if (!SWIG_IsOK(res2)) {
    9964           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetCondition" "', argument " "2"" of type '" "char const *""'");
    9965             :   }
    9966          15 :   arg2 = reinterpret_cast< char * >(buf2);
    9967             :   {
    9968             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9969          15 :     (arg1)->SetCondition((char const *)arg2);
    9970             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9971             :   }
    9972             :   resultobj = SWIG_Py_Void();
    9973          15 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    9974             :   return resultobj;
    9975           0 : fail:
    9976           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    9977             :   return NULL;
    9978             : }
    9979             : 
    9980             : 
    9981          11 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetCondition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
    9982             :   PyObject *resultobj = 0;
    9983             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
    9984          11 :   void *argp1 = 0 ;
    9985             :   int res1 = 0 ;
    9986          11 :   PyObject * obj0 = 0 ;
    9987             :   char *result = 0 ;
    9988             :   
    9989          11 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetCondition",&obj0)) SWIG_fail;
    9990          11 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
    9991          11 :   if (!SWIG_IsOK(res1)) {
    9992           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetCondition" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
    9993             :   }
    9994          11 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
    9995             :   {
    9996             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
    9997          11 :     result = (char *)(arg1)->GetCondition();
    9998             :     SWIG_PYTHON_THREAD_END_ALLOW;
    9999             :   }
   10000          11 :   resultobj = SWIG_FromCharPtr((const char *)result);
   10001          11 :   return resultobj;
   10002             : fail:
   10003             :   return NULL;
   10004             : }
   10005             : 
   10006             : 
   10007           0 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetAutoContinue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10008             :   PyObject *resultobj = 0;
   10009             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10010           0 :   void *argp1 = 0 ;
   10011             :   int res1 = 0 ;
   10012           0 :   PyObject * obj0 = 0 ;
   10013             :   bool result;
   10014             :   
   10015           0 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetAutoContinue",&obj0)) SWIG_fail;
   10016           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10017           0 :   if (!SWIG_IsOK(res1)) {
   10018           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10019             :   }
   10020           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10021             :   {
   10022             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10023           0 :     result = (bool)(arg1)->GetAutoContinue();
   10024             :     SWIG_PYTHON_THREAD_END_ALLOW;
   10025             :   }
   10026             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
   10027           0 :   return resultobj;
   10028             : fail:
   10029             :   return NULL;
   10030             : }
   10031             : 
   10032             : 
   10033           1 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetAutoContinue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10034             :   PyObject *resultobj = 0;
   10035             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10036             :   bool arg2 ;
   10037           1 :   void *argp1 = 0 ;
   10038             :   int res1 = 0 ;
   10039             :   bool val2 ;
   10040             :   int ecode2 = 0 ;
   10041           1 :   PyObject * obj0 = 0 ;
   10042           1 :   PyObject * obj1 = 0 ;
   10043             :   
   10044           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetAutoContinue",&obj0,&obj1)) SWIG_fail;
   10045           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10046           1 :   if (!SWIG_IsOK(res1)) {
   10047           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetAutoContinue" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10048             :   }
   10049           1 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10050           1 :   ecode2 = SWIG_AsVal_bool(obj1, &val2);
   10051             :   if (!SWIG_IsOK(ecode2)) {
   10052           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointLocation_SetAutoContinue" "', argument " "2"" of type '" "bool""'");
   10053             :   } 
   10054             :   arg2 = static_cast< bool >(val2);
   10055             :   {
   10056             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10057           1 :     (arg1)->SetAutoContinue(arg2);
   10058             :     SWIG_PYTHON_THREAD_END_ALLOW;
   10059             :   }
   10060             :   resultobj = SWIG_Py_Void();
   10061           1 :   return resultobj;
   10062             : fail:
   10063             :   return NULL;
   10064             : }
   10065             : 
   10066             : 
   10067           0 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10068             :   PyObject *resultobj = 0;
   10069             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10070             :   char *arg2 = (char *) 0 ;
   10071           0 :   void *argp1 = 0 ;
   10072             :   int res1 = 0 ;
   10073             :   int res2 ;
   10074           0 :   char *buf2 = 0 ;
   10075           0 :   int alloc2 = 0 ;
   10076           0 :   PyObject * obj0 = 0 ;
   10077           0 :   PyObject * obj1 = 0 ;
   10078             :   
   10079           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetScriptCallbackFunction",&obj0,&obj1)) SWIG_fail;
   10080           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10081           0 :   if (!SWIG_IsOK(res1)) {
   10082           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetScriptCallbackFunction" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10083             :   }
   10084           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10085           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10086           0 :   if (!SWIG_IsOK(res2)) {
   10087           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetScriptCallbackFunction" "', argument " "2"" of type '" "char const *""'");
   10088             :   }
   10089           0 :   arg2 = reinterpret_cast< char * >(buf2);
   10090             :   {
   10091             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10092           0 :     (arg1)->SetScriptCallbackFunction((char const *)arg2);
   10093             :     SWIG_PYTHON_THREAD_END_ALLOW;
   10094             :   }
   10095             :   resultobj = SWIG_Py_Void();
   10096           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
   10097             :   return resultobj;
   10098           0 : fail:
   10099           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
   10100             :   return NULL;
   10101             : }
   10102             : 
   10103             : 
   10104           0 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetScriptCallbackBody(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10105             :   PyObject *resultobj = 0;
   10106             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10107             :   char *arg2 = (char *) 0 ;
   10108           0 :   void *argp1 = 0 ;
   10109             :   int res1 = 0 ;
   10110             :   int res2 ;
   10111           0 :   char *buf2 = 0 ;
   10112           0 :   int alloc2 = 0 ;
   10113           0 :   PyObject * obj0 = 0 ;
   10114           0 :   PyObject * obj1 = 0 ;
   10115           0 :   lldb::SBError result;
   10116             :   
   10117           0 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetScriptCallbackBody",&obj0,&obj1)) SWIG_fail;
   10118           0 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10119           0 :   if (!SWIG_IsOK(res1)) {
   10120           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetScriptCallbackBody" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10121             :   }
   10122           0 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10123           0 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10124           0 :   if (!SWIG_IsOK(res2)) {
   10125           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetScriptCallbackBody" "', argument " "2"" of type '" "char const *""'");
   10126             :   }
   10127           0 :   arg2 = reinterpret_cast< char * >(buf2);
   10128             :   {
   10129             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10130           0 :     result = (arg1)->SetScriptCallbackBody((char const *)arg2);
   10131             :     SWIG_PYTHON_THREAD_END_ALLOW;
   10132             :   }
   10133           0 :   resultobj = SWIG_NewPointerObj((new lldb::SBError(static_cast< const lldb::SBError& >(result))), SWIGTYPE_p_lldb__SBError, SWIG_POINTER_OWN |  0 );
   10134           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
   10135             :   return resultobj;
   10136           0 : fail:
   10137           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
   10138             :   return NULL;
   10139             : }
   10140             : 
   10141             : 
   10142           2 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetCommandLineCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10143             :   PyObject *resultobj = 0;
   10144             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10145             :   lldb::SBStringList *arg2 = 0 ;
   10146           2 :   void *argp1 = 0 ;
   10147             :   int res1 = 0 ;
   10148           2 :   void *argp2 = 0 ;
   10149             :   int res2 = 0 ;
   10150           2 :   PyObject * obj0 = 0 ;
   10151           2 :   PyObject * obj1 = 0 ;
   10152             :   
   10153           2 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetCommandLineCommands",&obj0,&obj1)) SWIG_fail;
   10154           2 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10155           2 :   if (!SWIG_IsOK(res1)) {
   10156           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10157             :   }
   10158           2 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10159           2 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
   10160           2 :   if (!SWIG_IsOK(res2)) {
   10161           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
   10162             :   }
   10163           2 :   if (!argp2) {
   10164           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpointLocation_SetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
   10165             :   }
   10166             :   arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
   10167             :   {
   10168             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10169           2 :     (arg1)->SetCommandLineCommands(*arg2);
   10170             :     SWIG_PYTHON_THREAD_END_ALLOW;
   10171             :   }
   10172             :   resultobj = SWIG_Py_Void();
   10173           2 :   return resultobj;
   10174             : fail:
   10175             :   return NULL;
   10176             : }
   10177             : 
   10178             : 
   10179           4 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetCommandLineCommands(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10180             :   PyObject *resultobj = 0;
   10181             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10182             :   lldb::SBStringList *arg2 = 0 ;
   10183           4 :   void *argp1 = 0 ;
   10184             :   int res1 = 0 ;
   10185           4 :   void *argp2 = 0 ;
   10186             :   int res2 = 0 ;
   10187           4 :   PyObject * obj0 = 0 ;
   10188           4 :   PyObject * obj1 = 0 ;
   10189             :   bool result;
   10190             :   
   10191           4 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_GetCommandLineCommands",&obj0,&obj1)) SWIG_fail;
   10192           4 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10193           4 :   if (!SWIG_IsOK(res1)) {
   10194           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetCommandLineCommands" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10195             :   }
   10196           4 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10197           4 :   res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_lldb__SBStringList,  0 );
   10198           4 :   if (!SWIG_IsOK(res2)) {
   10199           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
   10200             :   }
   10201           4 :   if (!argp2) {
   10202           0 :     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SBBreakpointLocation_GetCommandLineCommands" "', argument " "2"" of type '" "lldb::SBStringList &""'"); 
   10203             :   }
   10204             :   arg2 = reinterpret_cast< lldb::SBStringList * >(argp2);
   10205             :   {
   10206             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10207           4 :     result = (bool)(arg1)->GetCommandLineCommands(*arg2);
   10208             :     SWIG_PYTHON_THREAD_END_ALLOW;
   10209             :   }
   10210             :   resultobj = SWIG_From_bool(static_cast< bool >(result));
   10211           4 :   return resultobj;
   10212             : fail:
   10213             :   return NULL;
   10214             : }
   10215             : 
   10216             : 
   10217           1 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10218             :   PyObject *resultobj = 0;
   10219             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10220             :   lldb::tid_t arg2 ;
   10221           1 :   void *argp1 = 0 ;
   10222             :   int res1 = 0 ;
   10223           1 :   PyObject * obj0 = 0 ;
   10224           1 :   PyObject * obj1 = 0 ;
   10225             :   
   10226           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetThreadID",&obj0,&obj1)) SWIG_fail;
   10227           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10228           1 :   if (!SWIG_IsOK(res1)) {
   10229           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10230             :   }
   10231           1 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10232             :   {
   10233             :     using namespace lldb_private;
   10234           1 :     if (PythonInteger::Check(obj1))
   10235             :     {
   10236           1 :       PythonInteger py_int(PyRefType::Borrowed, obj1);
   10237           1 :       arg2 = static_cast<lldb::tid_t>(py_int.GetInteger());
   10238             :     }
   10239             :     else
   10240             :     {
   10241           0 :       PyErr_SetString(PyExc_ValueError, "Expecting an integer");
   10242           0 :       return nullptr;
   10243             :     }
   10244             :   }
   10245             :   {
   10246             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10247           1 :     (arg1)->SetThreadID(arg2);
   10248             :     SWIG_PYTHON_THREAD_END_ALLOW;
   10249             :   }
   10250             :   resultobj = SWIG_Py_Void();
   10251           1 :   return resultobj;
   10252             : fail:
   10253             :   return NULL;
   10254             : }
   10255             : 
   10256             : 
   10257           1 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadID(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10258             :   PyObject *resultobj = 0;
   10259             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10260           1 :   void *argp1 = 0 ;
   10261             :   int res1 = 0 ;
   10262           1 :   PyObject * obj0 = 0 ;
   10263             :   lldb::tid_t result;
   10264             :   
   10265           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetThreadID",&obj0)) SWIG_fail;
   10266           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10267           1 :   if (!SWIG_IsOK(res1)) {
   10268           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetThreadID" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10269             :   }
   10270           1 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10271             :   {
   10272             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10273           1 :     result = (lldb::tid_t)(arg1)->GetThreadID();
   10274             :     SWIG_PYTHON_THREAD_END_ALLOW;
   10275             :   }
   10276           1 :   resultobj = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
   10277           1 :   return resultobj;
   10278             : fail:
   10279             :   return NULL;
   10280             : }
   10281             : 
   10282             : 
   10283           1 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10284             :   PyObject *resultobj = 0;
   10285             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10286             :   uint32_t arg2 ;
   10287           1 :   void *argp1 = 0 ;
   10288             :   int res1 = 0 ;
   10289             :   unsigned int val2 ;
   10290             :   int ecode2 = 0 ;
   10291           1 :   PyObject * obj0 = 0 ;
   10292           1 :   PyObject * obj1 = 0 ;
   10293             :   
   10294           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetThreadIndex",&obj0,&obj1)) SWIG_fail;
   10295           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10296           1 :   if (!SWIG_IsOK(res1)) {
   10297           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10298             :   }
   10299           1 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10300           1 :   ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
   10301           1 :   if (!SWIG_IsOK(ecode2)) {
   10302           0 :     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SBBreakpointLocation_SetThreadIndex" "', argument " "2"" of type '" "uint32_t""'");
   10303             :   } 
   10304             :   arg2 = static_cast< uint32_t >(val2);
   10305             :   {
   10306             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10307           1 :     (arg1)->SetThreadIndex(arg2);
   10308             :     SWIG_PYTHON_THREAD_END_ALLOW;
   10309             :   }
   10310             :   resultobj = SWIG_Py_Void();
   10311           1 :   return resultobj;
   10312             : fail:
   10313             :   return NULL;
   10314             : }
   10315             : 
   10316             : 
   10317           1 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10318             :   PyObject *resultobj = 0;
   10319             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10320           1 :   void *argp1 = 0 ;
   10321             :   int res1 = 0 ;
   10322           1 :   PyObject * obj0 = 0 ;
   10323             :   uint32_t result;
   10324             :   
   10325           1 :   if (!PyArg_ParseTuple(args,(char *)"O:SBBreakpointLocation_GetThreadIndex",&obj0)) SWIG_fail;
   10326           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10327           1 :   if (!SWIG_IsOK(res1)) {
   10328           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_GetThreadIndex" "', argument " "1"" of type '" "lldb::SBBreakpointLocation const *""'"); 
   10329             :   }
   10330           1 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10331             :   {
   10332             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10333           1 :     result = (uint32_t)((lldb::SBBreakpointLocation const *)arg1)->GetThreadIndex();
   10334             :     SWIG_PYTHON_THREAD_END_ALLOW;
   10335             :   }
   10336             :   resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
   10337           1 :   return resultobj;
   10338             : fail:
   10339             :   return NULL;
   10340             : }
   10341             : 
   10342             : 
   10343           1 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_SetThreadName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10344             :   PyObject *resultobj = 0;
   10345             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ;
   10346             :   char *arg2 = (char *) 0 ;
   10347           1 :   void *argp1 = 0 ;
   10348             :   int res1 = 0 ;
   10349             :   int res2 ;
   10350           1 :   char *buf2 = 0 ;
   10351           1 :   int alloc2 = 0 ;
   10352           1 :   PyObject * obj0 = 0 ;
   10353           1 :   PyObject * obj1 = 0 ;
   10354             :   
   10355           1 :   if (!PyArg_ParseTuple(args,(char *)"OO:SBBreakpointLocation_SetThreadName",&obj0,&obj1)) SWIG_fail;
   10356           1 :   res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lldb__SBBreakpointLocation, 0 |  0 );
   10357           1 :   if (!SWIG_IsOK(res1)) {
   10358           0 :     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SBBreakpointLocation_SetThreadName" "', argument " "1"" of type '" "lldb::SBBreakpointLocation *""'"); 
   10359             :   }
   10360           1 :   arg1 = reinterpret_cast< lldb::SBBreakpointLocation * >(argp1);
   10361           1 :   res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
   10362           1 :   if (!SWIG_IsOK(res2)) {
   10363           0 :     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SBBreakpointLocation_SetThreadName" "', argument " "2"" of type '" "char const *""'");
   10364             :   }
   10365           1 :   arg2 = reinterpret_cast< char * >(buf2);
   10366             :   {
   10367             :     SWIG_PYTHON_THREAD_BEGIN_ALLOW;
   10368           1 :     (arg1)->SetThreadName((char const *)arg2);
   10369             :     SWIG_PYTHON_THREAD_END_ALLOW;
   10370             :   }
   10371             :   resultobj = SWIG_Py_Void();
   10372           1 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
   10373             :   return resultobj;
   10374           0 : fail:
   10375           0 :   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
   10376             :   return NULL;
   10377             : }
   10378             : 
   10379             : 
   10380           1 : SWIGINTERN PyObject *_wrap_SBBreakpointLocation_GetThreadName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   10381             :   PyObject *resultobj = 0;
   10382             :   lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation