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